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


#define SWIG_VERSION 0x040101
#define SWIGPYTHON
#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(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

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

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

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

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

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

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

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


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use 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 object mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


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

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

#endif

#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


SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
  return (char *)PyUnicode_AsUTF8(str);
#else
  return PyString_AsString(str);
#endif
}

/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
 * with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)


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

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

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

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

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

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


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

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    const char *tmp = SWIG_Python_str_AsChar(old_str);
    PyErr_Clear();
    Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

#ifdef __cplusplus
}
#endif


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

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

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

/* Common SWIG API */

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

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

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

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

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

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

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

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


/* Runtime API */

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

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


/* Runtime API implementation */

/* Error manipulation */

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

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

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

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

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

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

#else

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

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

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

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

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

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

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
swig_varlink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  Py_DecRef(str);
  Py_DecRef(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
swig_varlink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
swig_varlink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN PyTypeObject*
swig_varlink_type(void) {
  static char varlink__doc__[] = "Swig var link object";
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      "swigvarlink",                      /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /*tp_print*/
#else
      (Py_ssize_t)0,                      /*tp_vectorcall_offset*/
#endif
      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) swig_varlink_repr,       /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) swig_varlink_str,        /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      varlink__doc__,                     /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
  }
  return &varlink_type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


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

#ifdef __cplusplus
}
#endif

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

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

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

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

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

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

/* SwigPyClientData */

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

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

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


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

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

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

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


#ifdef SWIGPYTHON_BUILTIN

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

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

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

#endif

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

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

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

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

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# 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
    } else {
      Py_DecRef(repr);
      repr = NULL;
    }
  }
  return repr;
}

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

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

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  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);

static PyObject* Swig_Capsule_global = NULL;

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

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

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

      PyErr_Restore(type, value, traceback);

      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(Swig_Capsule_global);
  }
  Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
  Py_XDECREF(sobj->dict);
#endif
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

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

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

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

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

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

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

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

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

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
    sobj->dict = 0;
#endif
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

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

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

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

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

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

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

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

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

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

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

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

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

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

static PyObject *Swig_This_global = NULL;

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

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

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

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

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

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

  obj = 0;

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

/* Acquire a pointer value */

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

/* Convert a pointer value */

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

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

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

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

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

/* Convert a packed pointer value */

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

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

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

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
        inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


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

/* Create a new pointer object */

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

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
        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
      if (newobj) {
        newobj->dict = 0;
      }
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

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

/* Create a new packed object */

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

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

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

static PyObject *Swig_TypeCache_global = NULL;

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

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


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

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
    return;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
  Py_DECREF(SWIG_globals());
  Swig_Globals_global = NULL;
  Py_DECREF(SWIG_Python_TypeCache());
  Swig_TypeCache_global = NULL;
  Swig_Capsule_global = NULL;
}

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

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

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

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      const char *tmp = SWIG_Python_str_AsChar(old_str);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      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);
	} 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();
  }
  return result;
}

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

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

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

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
    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) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



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


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

#define SWIGTYPE_p_ASX swig_types[0]
#define SWIGTYPE_p_AUCPI swig_types[1]
#define SWIGTYPE_p_AUDLibor swig_types[2]
#define SWIGTYPE_p_AbcdFunction swig_types[3]
#define SWIGTYPE_p_AbcdMathFunction swig_types[4]
#define SWIGTYPE_p_AbcdVol swig_types[5]
#define SWIGTYPE_p_AdaptiveRungeKuttaT_double_t swig_types[6]
#define SWIGTYPE_p_AmericanExercise swig_types[7]
#define SWIGTYPE_p_AmortizingCmsRateBond swig_types[8]
#define SWIGTYPE_p_AmortizingFixedRateBond swig_types[9]
#define SWIGTYPE_p_AmortizingFloatingRateBond swig_types[10]
#define SWIGTYPE_p_AmortizingPayment swig_types[11]
#define SWIGTYPE_p_AnalyticAmericanMargrabeEngine swig_types[12]
#define SWIGTYPE_p_AnalyticBSMHullWhiteEngine swig_types[13]
#define SWIGTYPE_p_AnalyticBarrierEngine swig_types[14]
#define SWIGTYPE_p_AnalyticBinaryBarrierEngine swig_types[15]
#define SWIGTYPE_p_AnalyticCEVEngine swig_types[16]
#define SWIGTYPE_p_AnalyticCapFloorEngine swig_types[17]
#define SWIGTYPE_p_AnalyticCliquetEngine swig_types[18]
#define SWIGTYPE_p_AnalyticComplexChooserEngine swig_types[19]
#define SWIGTYPE_p_AnalyticCompoundOptionEngine swig_types[20]
#define SWIGTYPE_p_AnalyticContinuousFixedLookbackEngine swig_types[21]
#define SWIGTYPE_p_AnalyticContinuousFloatingLookbackEngine swig_types[22]
#define SWIGTYPE_p_AnalyticContinuousGeometricAveragePriceAsianEngine swig_types[23]
#define SWIGTYPE_p_AnalyticContinuousGeometricAveragePriceAsianHestonEngine swig_types[24]
#define SWIGTYPE_p_AnalyticContinuousPartialFixedLookbackEngine swig_types[25]
#define SWIGTYPE_p_AnalyticContinuousPartialFloatingLookbackEngine swig_types[26]
#define SWIGTYPE_p_AnalyticDigitalAmericanEngine swig_types[27]
#define SWIGTYPE_p_AnalyticDigitalAmericanKOEngine swig_types[28]
#define SWIGTYPE_p_AnalyticDiscreteGeometricAveragePriceAsianEngine swig_types[29]
#define SWIGTYPE_p_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine swig_types[30]
#define SWIGTYPE_p_AnalyticDiscreteGeometricAverageStrikeAsianEngine swig_types[31]
#define SWIGTYPE_p_AnalyticDividendEuropeanEngine swig_types[32]
#define SWIGTYPE_p_AnalyticDoubleBarrierBinaryEngine swig_types[33]
#define SWIGTYPE_p_AnalyticDoubleBarrierEngine swig_types[34]
#define SWIGTYPE_p_AnalyticEuropeanEngine swig_types[35]
#define SWIGTYPE_p_AnalyticEuropeanMargrabeEngine swig_types[36]
#define SWIGTYPE_p_AnalyticGJRGARCHEngine swig_types[37]
#define SWIGTYPE_p_AnalyticH1HWEngine swig_types[38]
#define SWIGTYPE_p_AnalyticHaganPricer swig_types[39]
#define SWIGTYPE_p_AnalyticHestonEngine swig_types[40]
#define SWIGTYPE_p_AnalyticHestonEngine__Integration swig_types[41]
#define SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha swig_types[42]
#define SWIGTYPE_p_AnalyticHestonForwardEuropeanEngine swig_types[43]
#define SWIGTYPE_p_AnalyticHestonHullWhiteEngine swig_types[44]
#define SWIGTYPE_p_AnalyticPTDHestonEngine swig_types[45]
#define SWIGTYPE_p_AnalyticPartialTimeBarrierOptionEngine swig_types[46]
#define SWIGTYPE_p_AnalyticPerformanceEngine swig_types[47]
#define SWIGTYPE_p_AnalyticSimpleChooserEngine swig_types[48]
#define SWIGTYPE_p_AndreasenHugeLocalVolAdapter swig_types[49]
#define SWIGTYPE_p_AndreasenHugeVolatilityAdapter swig_types[50]
#define SWIGTYPE_p_AndreasenHugeVolatilityInterpl swig_types[51]
#define SWIGTYPE_p_Aonia swig_types[52]
#define SWIGTYPE_p_ArithmeticAverageOIS swig_types[53]
#define SWIGTYPE_p_ArithmeticOISRateHelper swig_types[54]
#define SWIGTYPE_p_Array swig_types[55]
#define SWIGTYPE_p_AssetOrNothingPayoff swig_types[56]
#define SWIGTYPE_p_AssetSwap swig_types[57]
#define SWIGTYPE_p_Average swig_types[58]
#define SWIGTYPE_p_AverageBasketPayoff swig_types[59]
#define SWIGTYPE_p_AveragingRatePricer swig_types[60]
#define SWIGTYPE_p_BFGS swig_types[61]
#define SWIGTYPE_p_BSMRNDCalculator swig_types[62]
#define SWIGTYPE_p_BachelierCapFloorEngine swig_types[63]
#define SWIGTYPE_p_BachelierSwaptionEngine swig_types[64]
#define SWIGTYPE_p_BachelierYoYInflationCouponPricer swig_types[65]
#define SWIGTYPE_p_BackwardFlat swig_types[66]
#define SWIGTYPE_p_BaroneAdesiWhaleyApproximationEngine swig_types[67]
#define SWIGTYPE_p_Barrier swig_types[68]
#define SWIGTYPE_p_BarrierOption swig_types[69]
#define SWIGTYPE_p_BasketOption swig_types[70]
#define SWIGTYPE_p_BasketPayoff swig_types[71]
#define SWIGTYPE_p_BatesEngine swig_types[72]
#define SWIGTYPE_p_BatesModel swig_types[73]
#define SWIGTYPE_p_BatesProcess swig_types[74]
#define SWIGTYPE_p_Bbsw swig_types[75]
#define SWIGTYPE_p_Bbsw1M swig_types[76]
#define SWIGTYPE_p_Bbsw2M swig_types[77]
#define SWIGTYPE_p_Bbsw3M swig_types[78]
#define SWIGTYPE_p_Bbsw4M swig_types[79]
#define SWIGTYPE_p_Bbsw5M swig_types[80]
#define SWIGTYPE_p_Bbsw6M swig_types[81]
#define SWIGTYPE_p_BermudanExercise swig_types[82]
#define SWIGTYPE_p_BiCGstab swig_types[83]
#define SWIGTYPE_p_Bibor swig_types[84]
#define SWIGTYPE_p_Bibor1M swig_types[85]
#define SWIGTYPE_p_Bibor1Y swig_types[86]
#define SWIGTYPE_p_Bibor2M swig_types[87]
#define SWIGTYPE_p_Bibor3M swig_types[88]
#define SWIGTYPE_p_Bibor6M swig_types[89]
#define SWIGTYPE_p_Bibor9M swig_types[90]
#define SWIGTYPE_p_BiborSW swig_types[91]
#define SWIGTYPE_p_Bicubic swig_types[92]
#define SWIGTYPE_p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t swig_types[93]
#define SWIGTYPE_p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t swig_types[94]
#define SWIGTYPE_p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t swig_types[95]
#define SWIGTYPE_p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t swig_types[96]
#define SWIGTYPE_p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t swig_types[97]
#define SWIGTYPE_p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t swig_types[98]
#define SWIGTYPE_p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t swig_types[99]
#define SWIGTYPE_p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t swig_types[100]
#define SWIGTYPE_p_BinomialConvertibleEngineT_CoxRossRubinstein_t swig_types[101]
#define SWIGTYPE_p_BinomialConvertibleEngineT_JarrowRudd_t swig_types[102]
#define SWIGTYPE_p_BinomialConvertibleEngineT_Joshi4_t swig_types[103]
#define SWIGTYPE_p_BinomialConvertibleEngineT_LeisenReimer_t swig_types[104]
#define SWIGTYPE_p_BinomialConvertibleEngineT_Tian_t swig_types[105]
#define SWIGTYPE_p_BinomialConvertibleEngineT_Trigeorgis_t swig_types[106]
#define SWIGTYPE_p_BinomialDistribution swig_types[107]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[108]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[109]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[110]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[111]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[112]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[113]
#define SWIGTYPE_p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t swig_types[114]
#define SWIGTYPE_p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t swig_types[115]
#define SWIGTYPE_p_BinomialVanillaEngineT_CoxRossRubinstein_t swig_types[116]
#define SWIGTYPE_p_BinomialVanillaEngineT_JarrowRudd_t swig_types[117]
#define SWIGTYPE_p_BinomialVanillaEngineT_Joshi4_t swig_types[118]
#define SWIGTYPE_p_BinomialVanillaEngineT_LeisenReimer_t swig_types[119]
#define SWIGTYPE_p_BinomialVanillaEngineT_Tian_t swig_types[120]
#define SWIGTYPE_p_BinomialVanillaEngineT_Trigeorgis_t swig_types[121]
#define SWIGTYPE_p_Bisection swig_types[122]
#define SWIGTYPE_p_BivariateCumulativeNormalDistribution swig_types[123]
#define SWIGTYPE_p_BivariateCumulativeNormalDistributionDr78 swig_types[124]
#define SWIGTYPE_p_BivariateCumulativeNormalDistributionWe04DP swig_types[125]
#define SWIGTYPE_p_BjerksundStenslandApproximationEngine swig_types[126]
#define SWIGTYPE_p_Bkbm swig_types[127]
#define SWIGTYPE_p_Bkbm1M swig_types[128]
#define SWIGTYPE_p_Bkbm2M swig_types[129]
#define SWIGTYPE_p_Bkbm3M swig_types[130]
#define SWIGTYPE_p_Bkbm4M swig_types[131]
#define SWIGTYPE_p_Bkbm5M swig_types[132]
#define SWIGTYPE_p_Bkbm6M swig_types[133]
#define SWIGTYPE_p_BlackCalculator swig_types[134]
#define SWIGTYPE_p_BlackCalibrationHelper swig_types[135]
#define SWIGTYPE_p_BlackCallableFixedRateBondEngine swig_types[136]
#define SWIGTYPE_p_BlackCapFloorEngine swig_types[137]
#define SWIGTYPE_p_BlackCdsOptionEngine swig_types[138]
#define SWIGTYPE_p_BlackConstantVol swig_types[139]
#define SWIGTYPE_p_BlackDeltaCalculator swig_types[140]
#define SWIGTYPE_p_BlackIborCouponPricer swig_types[141]
#define SWIGTYPE_p_BlackKarasinski swig_types[142]
#define SWIGTYPE_p_BlackProcess swig_types[143]
#define SWIGTYPE_p_BlackScholesMertonProcess swig_types[144]
#define SWIGTYPE_p_BlackScholesProcess swig_types[145]
#define SWIGTYPE_p_BlackSwaptionEngine swig_types[146]
#define SWIGTYPE_p_BlackVarianceCurve swig_types[147]
#define SWIGTYPE_p_BlackVarianceSurface swig_types[148]
#define SWIGTYPE_p_BlackVolTermStructure swig_types[149]
#define SWIGTYPE_p_BlackYoYInflationCouponPricer swig_types[150]
#define SWIGTYPE_p_Bond swig_types[151]
#define SWIGTYPE_p_BondForward swig_types[152]
#define SWIGTYPE_p_BondFunctions swig_types[153]
#define SWIGTYPE_p_BondHelper swig_types[154]
#define SWIGTYPE_p_BondPrice swig_types[155]
#define SWIGTYPE_p_BootstrapHelperT_YoYInflationTermStructure_t swig_types[156]
#define SWIGTYPE_p_BootstrapHelperT_YoYOptionletVolatilitySurface_t swig_types[157]
#define SWIGTYPE_p_BootstrapHelperT_ZeroInflationTermStructure_t swig_types[158]
#define SWIGTYPE_p_BoundaryConstraint swig_types[159]
#define SWIGTYPE_p_BoxMullerGaussianRngT_KnuthUniformRng_t swig_types[160]
#define SWIGTYPE_p_BoxMullerGaussianRngT_LecuyerUniformRng_t swig_types[161]
#define SWIGTYPE_p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t swig_types[162]
#define SWIGTYPE_p_BoxMullerGaussianRngT_Xoshiro256StarStarUniformRng_t swig_types[163]
#define SWIGTYPE_p_Brent swig_types[164]
#define SWIGTYPE_p_BrownianBridge swig_types[165]
#define SWIGTYPE_p_BrownianGenerator swig_types[166]
#define SWIGTYPE_p_BrownianGeneratorFactory swig_types[167]
#define SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg swig_types[168]
#define SWIGTYPE_p_Burley2020SobolRsg swig_types[169]
#define SWIGTYPE_p_CADLibor swig_types[170]
#define SWIGTYPE_p_CADLiborON swig_types[171]
#define SWIGTYPE_p_CEVRNDCalculator swig_types[172]
#define SWIGTYPE_p_CHFLibor swig_types[173]
#define SWIGTYPE_p_CLGaussianRngT_KnuthUniformRng_t swig_types[174]
#define SWIGTYPE_p_CLGaussianRngT_LecuyerUniformRng_t swig_types[175]
#define SWIGTYPE_p_CLGaussianRngT_MersenneTwisterUniformRng_t swig_types[176]
#define SWIGTYPE_p_CLGaussianRngT_Xoshiro256StarStarUniformRng_t swig_types[177]
#define SWIGTYPE_p_COSHestonEngine swig_types[178]
#define SWIGTYPE_p_CPI swig_types[179]
#define SWIGTYPE_p_CPIBond swig_types[180]
#define SWIGTYPE_p_CPICashFlow swig_types[181]
#define SWIGTYPE_p_CPICoupon swig_types[182]
#define SWIGTYPE_p_CPICouponPricer swig_types[183]
#define SWIGTYPE_p_CPISwap swig_types[184]
#define SWIGTYPE_p_Calendar swig_types[185]
#define SWIGTYPE_p_CalibratedModel swig_types[186]
#define SWIGTYPE_p_CalibrationHelper swig_types[187]
#define SWIGTYPE_p_CalibrationSet swig_types[188]
#define SWIGTYPE_p_Callability swig_types[189]
#define SWIGTYPE_p_CallableBond swig_types[190]
#define SWIGTYPE_p_CallableFixedRateBond swig_types[191]
#define SWIGTYPE_p_CallableZeroCouponBond swig_types[192]
#define SWIGTYPE_p_Cap swig_types[193]
#define SWIGTYPE_p_CapFloor swig_types[194]
#define SWIGTYPE_p_CapFloorTermVolCurve swig_types[195]
#define SWIGTYPE_p_CapFloorTermVolSurface swig_types[196]
#define SWIGTYPE_p_CapFloorTermVolatilityStructure swig_types[197]
#define SWIGTYPE_p_CapHelper swig_types[198]
#define SWIGTYPE_p_CappedFlooredCmsCoupon swig_types[199]
#define SWIGTYPE_p_CappedFlooredCmsSpreadCoupon swig_types[200]
#define SWIGTYPE_p_CappedFlooredCoupon swig_types[201]
#define SWIGTYPE_p_CappedFlooredIborCoupon swig_types[202]
#define SWIGTYPE_p_CappedFlooredYoYInflationCoupon swig_types[203]
#define SWIGTYPE_p_CashFlow swig_types[204]
#define SWIGTYPE_p_CashFlows swig_types[205]
#define SWIGTYPE_p_CashOrNothingPayoff swig_types[206]
#define SWIGTYPE_p_Cdor swig_types[207]
#define SWIGTYPE_p_CdsOption swig_types[208]
#define SWIGTYPE_p_CeilingTruncation swig_types[209]
#define SWIGTYPE_p_ChebyshevInterpolation swig_types[210]
#define SWIGTYPE_p_ChfLiborSwapIsdaFix swig_types[211]
#define SWIGTYPE_p_Claim swig_types[212]
#define SWIGTYPE_p_CliquetOption swig_types[213]
#define SWIGTYPE_p_ClosestRounding swig_types[214]
#define SWIGTYPE_p_CmsCoupon swig_types[215]
#define SWIGTYPE_p_CmsCouponPricer swig_types[216]
#define SWIGTYPE_p_CmsMarket swig_types[217]
#define SWIGTYPE_p_CmsMarketCalibration swig_types[218]
#define SWIGTYPE_p_CmsRateBond swig_types[219]
#define SWIGTYPE_p_CmsSpreadCoupon swig_types[220]
#define SWIGTYPE_p_CmsSpreadCouponPricer swig_types[221]
#define SWIGTYPE_p_Collar swig_types[222]
#define SWIGTYPE_p_ComplexChooserOption swig_types[223]
#define SWIGTYPE_p_CompositeConstraint swig_types[224]
#define SWIGTYPE_p_CompositeInstrument swig_types[225]
#define SWIGTYPE_p_CompositeQuoteT_BinaryFunction_t swig_types[226]
#define SWIGTYPE_p_CompositeZeroYieldStructureT_BinaryFunction_t swig_types[227]
#define SWIGTYPE_p_CompoundOption swig_types[228]
#define SWIGTYPE_p_CompoundingRatePricer swig_types[229]
#define SWIGTYPE_p_Concentrating1dMesher swig_types[230]
#define SWIGTYPE_p_Conditions swig_types[231]
#define SWIGTYPE_p_ConjugateGradient swig_types[232]
#define SWIGTYPE_p_ConstNotionalCrossCurrencyBasisSwapRateHelper swig_types[233]
#define SWIGTYPE_p_ConstantEstimator swig_types[234]
#define SWIGTYPE_p_ConstantOptionletVolatility swig_types[235]
#define SWIGTYPE_p_ConstantParameter swig_types[236]
#define SWIGTYPE_p_ConstantSwaptionVolatility swig_types[237]
#define SWIGTYPE_p_ConstantYoYOptionletVolatility swig_types[238]
#define SWIGTYPE_p_Constraint swig_types[239]
#define SWIGTYPE_p_ContinuousArithmeticAsianLevyEngine swig_types[240]
#define SWIGTYPE_p_ContinuousAveragingAsianOption swig_types[241]
#define SWIGTYPE_p_ContinuousFixedLookbackOption swig_types[242]
#define SWIGTYPE_p_ContinuousFloatingLookbackOption swig_types[243]
#define SWIGTYPE_p_ContinuousPartialFixedLookbackOption swig_types[244]
#define SWIGTYPE_p_ContinuousPartialFloatingLookbackOption swig_types[245]
#define SWIGTYPE_p_ControlVariate swig_types[246]
#define SWIGTYPE_p_ConvertibleFixedCouponBond swig_types[247]
#define SWIGTYPE_p_ConvertibleFloatingRateBond swig_types[248]
#define SWIGTYPE_p_ConvertibleZeroCouponBond swig_types[249]
#define SWIGTYPE_p_ConvexMonotone swig_types[250]
#define SWIGTYPE_p_Corra swig_types[251]
#define SWIGTYPE_p_Coupon swig_types[252]
#define SWIGTYPE_p_CoxIngersollRoss swig_types[253]
#define SWIGTYPE_p_CraigSneydScheme swig_types[254]
#define SWIGTYPE_p_CrankNicolsonScheme swig_types[255]
#define SWIGTYPE_p_CreditDefaultSwap swig_types[256]
#define SWIGTYPE_p_Cubic swig_types[257]
#define SWIGTYPE_p_CubicBSplinesFitting swig_types[258]
#define SWIGTYPE_p_CubicInterpolation swig_types[259]
#define SWIGTYPE_p_CumulativeBinomialDistribution swig_types[260]
#define SWIGTYPE_p_CumulativeChiSquareDistribution swig_types[261]
#define SWIGTYPE_p_CumulativeGammaDistribution swig_types[262]
#define SWIGTYPE_p_CumulativeNormalDistribution swig_types[263]
#define SWIGTYPE_p_CumulativePoissonDistribution swig_types[264]
#define SWIGTYPE_p_CumulativeStudentDistribution swig_types[265]
#define SWIGTYPE_p_Currency swig_types[266]
#define SWIGTYPE_p_CurveState swig_types[267]
#define SWIGTYPE_p_CustomRegion swig_types[268]
#define SWIGTYPE_p_DKKLibor swig_types[269]
#define SWIGTYPE_p_DMinus swig_types[270]
#define SWIGTYPE_p_DPlus swig_types[271]
#define SWIGTYPE_p_DPlusDMinus swig_types[272]
#define SWIGTYPE_p_DZero swig_types[273]
#define SWIGTYPE_p_DailyTenorLibor swig_types[274]
#define SWIGTYPE_p_Date swig_types[275]
#define SWIGTYPE_p_DateGeneration swig_types[276]
#define SWIGTYPE_p_DateParser swig_types[277]
#define SWIGTYPE_p_DatedOISRateHelper swig_types[278]
#define SWIGTYPE_p_DayCounter swig_types[279]
#define SWIGTYPE_p_DefaultBoundaryCondition swig_types[280]
#define SWIGTYPE_p_DefaultDensity swig_types[281]
#define SWIGTYPE_p_DefaultLogCubic swig_types[282]
#define SWIGTYPE_p_DefaultProbabilityHelper swig_types[283]
#define SWIGTYPE_p_DefaultProbabilityTermStructure swig_types[284]
#define SWIGTYPE_p_DeltaVolQuote swig_types[285]
#define SWIGTYPE_p_DepositRateHelper swig_types[286]
#define SWIGTYPE_p_DerivedQuoteT_UnaryFunction_t swig_types[287]
#define SWIGTYPE_p_Destr swig_types[288]
#define SWIGTYPE_p_DifferentialEvolution swig_types[289]
#define SWIGTYPE_p_DirichletBC swig_types[290]
#define SWIGTYPE_p_Discount swig_types[291]
#define SWIGTYPE_p_DiscountingBondEngine swig_types[292]
#define SWIGTYPE_p_DiscountingSwapEngine swig_types[293]
#define SWIGTYPE_p_DiscreteAveragingAsianOption swig_types[294]
#define SWIGTYPE_p_Dividend swig_types[295]
#define SWIGTYPE_p_DividendBarrierOption swig_types[296]
#define SWIGTYPE_p_DividendVanillaOption swig_types[297]
#define SWIGTYPE_p_DoubleBarrier swig_types[298]
#define SWIGTYPE_p_DoubleBarrierOption swig_types[299]
#define SWIGTYPE_p_DouglasScheme swig_types[300]
#define SWIGTYPE_p_DownRounding swig_types[301]
#define SWIGTYPE_p_Duration swig_types[302]
#define SWIGTYPE_p_EUHICP swig_types[303]
#define SWIGTYPE_p_EUHICPXT swig_types[304]
#define SWIGTYPE_p_EURLibor swig_types[305]
#define SWIGTYPE_p_EURLibor10M swig_types[306]
#define SWIGTYPE_p_EURLibor11M swig_types[307]
#define SWIGTYPE_p_EURLibor1M swig_types[308]
#define SWIGTYPE_p_EURLibor1Y swig_types[309]
#define SWIGTYPE_p_EURLibor2M swig_types[310]
#define SWIGTYPE_p_EURLibor2W swig_types[311]
#define SWIGTYPE_p_EURLibor3M swig_types[312]
#define SWIGTYPE_p_EURLibor4M swig_types[313]
#define SWIGTYPE_p_EURLibor5M swig_types[314]
#define SWIGTYPE_p_EURLibor6M swig_types[315]
#define SWIGTYPE_p_EURLibor7M swig_types[316]
#define SWIGTYPE_p_EURLibor8M swig_types[317]
#define SWIGTYPE_p_EURLibor9M swig_types[318]
#define SWIGTYPE_p_EURLiborSW swig_types[319]
#define SWIGTYPE_p_EndCriteria swig_types[320]
#define SWIGTYPE_p_EndCriteria__Type swig_types[321]
#define SWIGTYPE_p_Eonia swig_types[322]
#define SWIGTYPE_p_EquityCashFlow swig_types[323]
#define SWIGTYPE_p_EquityCashFlowPricer swig_types[324]
#define SWIGTYPE_p_EquityIndex swig_types[325]
#define SWIGTYPE_p_EquityQuantoCashFlowPricer swig_types[326]
#define SWIGTYPE_p_EquityTotalReturnSwap swig_types[327]
#define SWIGTYPE_p_Estr swig_types[328]
#define SWIGTYPE_p_EurLiborSwapIfrFix swig_types[329]
#define SWIGTYPE_p_EurLiborSwapIsdaFixA swig_types[330]
#define SWIGTYPE_p_EurLiborSwapIsdaFixB swig_types[331]
#define SWIGTYPE_p_Euribor swig_types[332]
#define SWIGTYPE_p_Euribor10M swig_types[333]
#define SWIGTYPE_p_Euribor11M swig_types[334]
#define SWIGTYPE_p_Euribor1M swig_types[335]
#define SWIGTYPE_p_Euribor1Y swig_types[336]
#define SWIGTYPE_p_Euribor2M swig_types[337]
#define SWIGTYPE_p_Euribor2W swig_types[338]
#define SWIGTYPE_p_Euribor365 swig_types[339]
#define SWIGTYPE_p_Euribor365_10M swig_types[340]
#define SWIGTYPE_p_Euribor365_11M swig_types[341]
#define SWIGTYPE_p_Euribor365_1M swig_types[342]
#define SWIGTYPE_p_Euribor365_1Y swig_types[343]
#define SWIGTYPE_p_Euribor365_2M swig_types[344]
#define SWIGTYPE_p_Euribor365_2W swig_types[345]
#define SWIGTYPE_p_Euribor365_3M swig_types[346]
#define SWIGTYPE_p_Euribor365_3W swig_types[347]
#define SWIGTYPE_p_Euribor365_4M swig_types[348]
#define SWIGTYPE_p_Euribor365_5M swig_types[349]
#define SWIGTYPE_p_Euribor365_6M swig_types[350]
#define SWIGTYPE_p_Euribor365_7M swig_types[351]
#define SWIGTYPE_p_Euribor365_8M swig_types[352]
#define SWIGTYPE_p_Euribor365_9M swig_types[353]
#define SWIGTYPE_p_Euribor365_SW swig_types[354]
#define SWIGTYPE_p_Euribor3M swig_types[355]
#define SWIGTYPE_p_Euribor3W swig_types[356]
#define SWIGTYPE_p_Euribor4M swig_types[357]
#define SWIGTYPE_p_Euribor5M swig_types[358]
#define SWIGTYPE_p_Euribor6M swig_types[359]
#define SWIGTYPE_p_Euribor7M swig_types[360]
#define SWIGTYPE_p_Euribor8M swig_types[361]
#define SWIGTYPE_p_Euribor9M swig_types[362]
#define SWIGTYPE_p_EuriborSW swig_types[363]
#define SWIGTYPE_p_EuriborSwapIfrFix swig_types[364]
#define SWIGTYPE_p_EuriborSwapIsdaFixA swig_types[365]
#define SWIGTYPE_p_EuriborSwapIsdaFixB swig_types[366]
#define SWIGTYPE_p_EuropeanExercise swig_types[367]
#define SWIGTYPE_p_EuropeanOption swig_types[368]
#define SWIGTYPE_p_EverestOption swig_types[369]
#define SWIGTYPE_p_EvolutionDescription swig_types[370]
#define SWIGTYPE_p_ExchangeRate swig_types[371]
#define SWIGTYPE_p_ExchangeRateManager swig_types[372]
#define SWIGTYPE_p_Exercise swig_types[373]
#define SWIGTYPE_p_ExpSinhIntegral swig_types[374]
#define SWIGTYPE_p_ExplicitEulerScheme swig_types[375]
#define SWIGTYPE_p_ExponentialFittingHestonEngine swig_types[376]
#define SWIGTYPE_p_ExponentialForwardCorrelation swig_types[377]
#define SWIGTYPE_p_ExponentialJump1dMesher swig_types[378]
#define SWIGTYPE_p_ExponentialSplinesFitting swig_types[379]
#define SWIGTYPE_p_ExtOUWithJumpsProcess swig_types[380]
#define SWIGTYPE_p_ExtendedCoxIngersollRoss swig_types[381]
#define SWIGTYPE_p_ExtendedOrnsteinUhlenbeckProcess swig_types[382]
#define SWIGTYPE_p_Extrapolation swig_types[383]
#define SWIGTYPE_p_FFTVarianceGammaEngine swig_types[384]
#define SWIGTYPE_p_FRHICP swig_types[385]
#define SWIGTYPE_p_FaceValueAccrualClaim swig_types[386]
#define SWIGTYPE_p_FaceValueClaim swig_types[387]
#define SWIGTYPE_p_FalsePosition swig_types[388]
#define SWIGTYPE_p_Fd2dBlackScholesVanillaEngine swig_types[389]
#define SWIGTYPE_p_FdBatesVanillaEngine swig_types[390]
#define SWIGTYPE_p_FdBlackScholesAsianEngine swig_types[391]
#define SWIGTYPE_p_FdBlackScholesBarrierEngine swig_types[392]
#define SWIGTYPE_p_FdBlackScholesRebateEngine swig_types[393]
#define SWIGTYPE_p_FdBlackScholesShoutEngine swig_types[394]
#define SWIGTYPE_p_FdBlackScholesVanillaEngine swig_types[395]
#define SWIGTYPE_p_FdCEVVanillaEngine swig_types[396]
#define SWIGTYPE_p_FdG2SwaptionEngine swig_types[397]
#define SWIGTYPE_p_FdHestonBarrierEngine swig_types[398]
#define SWIGTYPE_p_FdHestonDoubleBarrierEngine swig_types[399]
#define SWIGTYPE_p_FdHestonHullWhiteVanillaEngine swig_types[400]
#define SWIGTYPE_p_FdHestonRebateEngine swig_types[401]
#define SWIGTYPE_p_FdHestonVanillaEngine swig_types[402]
#define SWIGTYPE_p_FdHullWhiteSwaptionEngine swig_types[403]
#define SWIGTYPE_p_FdOrnsteinUhlenbeckVanillaEngine swig_types[404]
#define SWIGTYPE_p_FdSabrVanillaEngine swig_types[405]
#define SWIGTYPE_p_FdSimpleBSSwingEngine swig_types[406]
#define SWIGTYPE_p_FdSimpleExtOUJumpSwingEngine swig_types[407]
#define SWIGTYPE_p_Fdm1DimSolver swig_types[408]
#define SWIGTYPE_p_Fdm1dMesher swig_types[409]
#define SWIGTYPE_p_Fdm2DimSolver swig_types[410]
#define SWIGTYPE_p_Fdm2dBlackScholesOp swig_types[411]
#define SWIGTYPE_p_Fdm2dBlackScholesSolver swig_types[412]
#define SWIGTYPE_p_Fdm3DimSolver swig_types[413]
#define SWIGTYPE_p_FdmAffineModelSwapInnerValueT_G2_t swig_types[414]
#define SWIGTYPE_p_FdmAffineModelSwapInnerValueT_HullWhite_t swig_types[415]
#define SWIGTYPE_p_FdmAmericanStepCondition swig_types[416]
#define SWIGTYPE_p_FdmArithmeticAverageCondition swig_types[417]
#define SWIGTYPE_p_FdmBackwardSolver swig_types[418]
#define SWIGTYPE_p_FdmBatesOp swig_types[419]
#define SWIGTYPE_p_FdmBermudanStepCondition swig_types[420]
#define SWIGTYPE_p_FdmBlackScholesFwdOp swig_types[421]
#define SWIGTYPE_p_FdmBlackScholesMesher swig_types[422]
#define SWIGTYPE_p_FdmBlackScholesOp swig_types[423]
#define SWIGTYPE_p_FdmBoundaryCondition swig_types[424]
#define SWIGTYPE_p_FdmCEV1dMesher swig_types[425]
#define SWIGTYPE_p_FdmCEVOp swig_types[426]
#define SWIGTYPE_p_FdmCellAveragingInnerValue swig_types[427]
#define SWIGTYPE_p_FdmDirichletBoundary swig_types[428]
#define SWIGTYPE_p_FdmDiscountDirichletBoundary swig_types[429]
#define SWIGTYPE_p_FdmDividendHandler swig_types[430]
#define SWIGTYPE_p_FdmDupire1dOp swig_types[431]
#define SWIGTYPE_p_FdmG2Op swig_types[432]
#define SWIGTYPE_p_FdmG2Solver swig_types[433]
#define SWIGTYPE_p_FdmHestonFwdOp swig_types[434]
#define SWIGTYPE_p_FdmHestonGreensFct swig_types[435]
#define SWIGTYPE_p_FdmHestonHullWhiteOp swig_types[436]
#define SWIGTYPE_p_FdmHestonHullWhiteSolver swig_types[437]
#define SWIGTYPE_p_FdmHestonLocalVolatilityVarianceMesher swig_types[438]
#define SWIGTYPE_p_FdmHestonOp swig_types[439]
#define SWIGTYPE_p_FdmHestonSolver swig_types[440]
#define SWIGTYPE_p_FdmHestonVarianceMesher swig_types[441]
#define SWIGTYPE_p_FdmHullWhiteOp swig_types[442]
#define SWIGTYPE_p_FdmHullWhiteSolver swig_types[443]
#define SWIGTYPE_p_FdmIndicesOnBoundary swig_types[444]
#define SWIGTYPE_p_FdmInnerValueCalculator swig_types[445]
#define SWIGTYPE_p_FdmInnerValueCalculatorProxy swig_types[446]
#define SWIGTYPE_p_FdmLinearOp swig_types[447]
#define SWIGTYPE_p_FdmLinearOpComposite swig_types[448]
#define SWIGTYPE_p_FdmLinearOpCompositeProxy swig_types[449]
#define SWIGTYPE_p_FdmLinearOpIterator swig_types[450]
#define SWIGTYPE_p_FdmLinearOpLayout swig_types[451]
#define SWIGTYPE_p_FdmLocalVolFwdOp swig_types[452]
#define SWIGTYPE_p_FdmLogBasketInnerValue swig_types[453]
#define SWIGTYPE_p_FdmLogInnerValue swig_types[454]
#define SWIGTYPE_p_FdmMesher swig_types[455]
#define SWIGTYPE_p_FdmMesherComposite swig_types[456]
#define SWIGTYPE_p_FdmNdimSolverT_4_t swig_types[457]
#define SWIGTYPE_p_FdmNdimSolverT_5_t swig_types[458]
#define SWIGTYPE_p_FdmNdimSolverT_6_t swig_types[459]
#define SWIGTYPE_p_FdmOrnsteinUhlenbeckOp swig_types[460]
#define SWIGTYPE_p_FdmQuantoHelper swig_types[461]
#define SWIGTYPE_p_FdmSabrOp swig_types[462]
#define SWIGTYPE_p_FdmSchemeDesc swig_types[463]
#define SWIGTYPE_p_FdmSimpleProcess1dMesher swig_types[464]
#define SWIGTYPE_p_FdmSimpleStorageCondition swig_types[465]
#define SWIGTYPE_p_FdmSimpleSwingCondition swig_types[466]
#define SWIGTYPE_p_FdmSnapshotCondition swig_types[467]
#define SWIGTYPE_p_FdmSolverDesc swig_types[468]
#define SWIGTYPE_p_FdmSquareRootFwdOp swig_types[469]
#define SWIGTYPE_p_FdmStepConditionComposite swig_types[470]
#define SWIGTYPE_p_FdmStepConditionProxy swig_types[471]
#define SWIGTYPE_p_FdmTimeDepDirichletBoundary swig_types[472]
#define SWIGTYPE_p_FdmZabrOp swig_types[473]
#define SWIGTYPE_p_FdmZeroInnerValue swig_types[474]
#define SWIGTYPE_p_FedFunds swig_types[475]
#define SWIGTYPE_p_FirstDerivativeOp swig_types[476]
#define SWIGTYPE_p_FittedBondDiscountCurve swig_types[477]
#define SWIGTYPE_p_FittingMethod swig_types[478]
#define SWIGTYPE_p_FixedDividend swig_types[479]
#define SWIGTYPE_p_FixedLocalVolSurface swig_types[480]
#define SWIGTYPE_p_FixedRateBond swig_types[481]
#define SWIGTYPE_p_FixedRateBondForward swig_types[482]
#define SWIGTYPE_p_FixedRateBondHelper swig_types[483]
#define SWIGTYPE_p_FixedRateCoupon swig_types[484]
#define SWIGTYPE_p_FlatForward swig_types[485]
#define SWIGTYPE_p_FlatHazardRate swig_types[486]
#define SWIGTYPE_p_FlatSmileSection swig_types[487]
#define SWIGTYPE_p_FloatFloatSwap swig_types[488]
#define SWIGTYPE_p_FloatFloatSwaption swig_types[489]
#define SWIGTYPE_p_FloatingRateBond swig_types[490]
#define SWIGTYPE_p_FloatingRateCoupon swig_types[491]
#define SWIGTYPE_p_FloatingRateCouponPricer swig_types[492]
#define SWIGTYPE_p_FloatingTypePayoff swig_types[493]
#define SWIGTYPE_p_Floor swig_types[494]
#define SWIGTYPE_p_FloorTruncation swig_types[495]
#define SWIGTYPE_p_Forward swig_types[496]
#define SWIGTYPE_p_ForwardEuropeanEngine swig_types[497]
#define SWIGTYPE_p_ForwardFlat swig_types[498]
#define SWIGTYPE_p_ForwardRate swig_types[499]
#define SWIGTYPE_p_ForwardRateAgreement swig_types[500]
#define SWIGTYPE_p_ForwardSpreadedTermStructure swig_types[501]
#define SWIGTYPE_p_ForwardVanillaOption swig_types[502]
#define SWIGTYPE_p_FraRateHelper swig_types[503]
#define SWIGTYPE_p_FractionalDividend swig_types[504]
#define SWIGTYPE_p_Futures swig_types[505]
#define SWIGTYPE_p_FuturesRateHelper swig_types[506]
#define SWIGTYPE_p_FxSwapRateHelper swig_types[507]
#define SWIGTYPE_p_G2 swig_types[508]
#define SWIGTYPE_p_G2ForwardProcess swig_types[509]
#define SWIGTYPE_p_G2Process swig_types[510]
#define SWIGTYPE_p_G2SwaptionEngine swig_types[511]
#define SWIGTYPE_p_GBPLibor swig_types[512]
#define SWIGTYPE_p_GBPLiborON swig_types[513]
#define SWIGTYPE_p_GBSMRNDCalculator swig_types[514]
#define SWIGTYPE_p_GFunctionFactory swig_types[515]
#define SWIGTYPE_p_GJRGARCHModel swig_types[516]
#define SWIGTYPE_p_GJRGARCHProcess swig_types[517]
#define SWIGTYPE_p_GMRES swig_types[518]
#define SWIGTYPE_p_GammaFunction swig_types[519]
#define SWIGTYPE_p_GapPayoff swig_types[520]
#define SWIGTYPE_p_GarmanKlassSigma1 swig_types[521]
#define SWIGTYPE_p_GarmanKlassSigma3 swig_types[522]
#define SWIGTYPE_p_GarmanKlassSigma4 swig_types[523]
#define SWIGTYPE_p_GarmanKlassSigma5 swig_types[524]
#define SWIGTYPE_p_GarmanKlassSigma6 swig_types[525]
#define SWIGTYPE_p_GarmanKohlagenProcess swig_types[526]
#define SWIGTYPE_p_GaussChebyshev2ndIntegration swig_types[527]
#define SWIGTYPE_p_GaussChebyshevIntegration swig_types[528]
#define SWIGTYPE_p_GaussGegenbauerIntegration swig_types[529]
#define SWIGTYPE_p_GaussHermiteIntegration swig_types[530]
#define SWIGTYPE_p_GaussHyperbolicIntegration swig_types[531]
#define SWIGTYPE_p_GaussJacobiIntegration swig_types[532]
#define SWIGTYPE_p_GaussKronrodAdaptive swig_types[533]
#define SWIGTYPE_p_GaussKronrodNonAdaptive swig_types[534]
#define SWIGTYPE_p_GaussLaguerreIntegration swig_types[535]
#define SWIGTYPE_p_GaussLegendreIntegration swig_types[536]
#define SWIGTYPE_p_GaussLobattoIntegral swig_types[537]
#define SWIGTYPE_p_Gaussian1dCapFloorEngine swig_types[538]
#define SWIGTYPE_p_Gaussian1dFloatFloatSwaptionEngine swig_types[539]
#define SWIGTYPE_p_Gaussian1dJamshidianSwaptionEngine swig_types[540]
#define SWIGTYPE_p_Gaussian1dModel swig_types[541]
#define SWIGTYPE_p_Gaussian1dNonstandardSwaptionEngine swig_types[542]
#define SWIGTYPE_p_Gaussian1dSwaptionEngine swig_types[543]
#define SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator swig_types[544]
#define SWIGTYPE_p_GaussianQuadrature swig_types[545]
#define SWIGTYPE_p_GaussianRandomGenerator swig_types[546]
#define SWIGTYPE_p_GaussianRandomSequenceGenerator swig_types[547]
#define SWIGTYPE_p_GaussianSimulatedAnnealing swig_types[548]
#define SWIGTYPE_p_GbpLiborSwapIsdaFix swig_types[549]
#define SWIGTYPE_p_GeneralizedBlackScholesProcess swig_types[550]
#define SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t swig_types[551]
#define SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t swig_types[552]
#define SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t swig_types[553]
#define SWIGTYPE_p_GeometricBrownianMotionProcess swig_types[554]
#define SWIGTYPE_p_GlobalLinearSimpleZeroCurve swig_types[555]
#define SWIGTYPE_p_Glued1dMesher swig_types[556]
#define SWIGTYPE_p_GridModelLocalVolSurface swig_types[557]
#define SWIGTYPE_p_Gsr swig_types[558]
#define SWIGTYPE_p_GsrProcess swig_types[559]
#define SWIGTYPE_p_HaltonRsg swig_types[560]
#define SWIGTYPE_p_HandleT_BlackVolTermStructure_t swig_types[561]
#define SWIGTYPE_p_HandleT_CalibratedModel_t swig_types[562]
#define SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t swig_types[563]
#define SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t swig_types[564]
#define SWIGTYPE_p_HandleT_DeltaVolQuote_t swig_types[565]
#define SWIGTYPE_p_HandleT_HestonModel_t swig_types[566]
#define SWIGTYPE_p_HandleT_LocalVolTermStructure_t swig_types[567]
#define SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t swig_types[568]
#define SWIGTYPE_p_HandleT_Quote_t swig_types[569]
#define SWIGTYPE_p_HandleT_ShortRateModel_t swig_types[570]
#define SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t swig_types[571]
#define SWIGTYPE_p_HandleT_YieldTermStructure_t swig_types[572]
#define SWIGTYPE_p_HandleT_YoYInflationTermStructure_t swig_types[573]
#define SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t swig_types[574]
#define SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t swig_types[575]
#define SWIGTYPE_p_HazardRate swig_types[576]
#define SWIGTYPE_p_HestonBlackVolSurface swig_types[577]
#define SWIGTYPE_p_HestonModel swig_types[578]
#define SWIGTYPE_p_HestonModelHelper swig_types[579]
#define SWIGTYPE_p_HestonProcess swig_types[580]
#define SWIGTYPE_p_HestonRNDCalculator swig_types[581]
#define SWIGTYPE_p_HestonSLVFDMModel swig_types[582]
#define SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams swig_types[583]
#define SWIGTYPE_p_HestonSLVMCModel swig_types[584]
#define SWIGTYPE_p_HestonSLVProcess swig_types[585]
#define SWIGTYPE_p_HimalayaOption swig_types[586]
#define SWIGTYPE_p_HullWhite swig_types[587]
#define SWIGTYPE_p_HullWhiteForwardProcess swig_types[588]
#define SWIGTYPE_p_HullWhiteProcess swig_types[589]
#define SWIGTYPE_p_HundsdorferScheme swig_types[590]
#define SWIGTYPE_p_IMM swig_types[591]
#define SWIGTYPE_p_IborCoupon swig_types[592]
#define SWIGTYPE_p_IborCouponPricer swig_types[593]
#define SWIGTYPE_p_IborIborBasisSwapRateHelper swig_types[594]
#define SWIGTYPE_p_IborIndex swig_types[595]
#define SWIGTYPE_p_ImplicitEulerScheme swig_types[596]
#define SWIGTYPE_p_ImpliedTermStructure swig_types[597]
#define SWIGTYPE_p_IncrementalStatistics swig_types[598]
#define SWIGTYPE_p_Index swig_types[599]
#define SWIGTYPE_p_IndexManager swig_types[600]
#define SWIGTYPE_p_IndexedCashFlow swig_types[601]
#define SWIGTYPE_p_InflationCoupon swig_types[602]
#define SWIGTYPE_p_InflationIndex swig_types[603]
#define SWIGTYPE_p_InflationTermStructure swig_types[604]
#define SWIGTYPE_p_Instrument swig_types[605]
#define SWIGTYPE_p_IntegralCdsEngine swig_types[606]
#define SWIGTYPE_p_IntegralEngine swig_types[607]
#define SWIGTYPE_p_Integration swig_types[608]
#define SWIGTYPE_p_InterestRate swig_types[609]
#define SWIGTYPE_p_InterestRateIndex swig_types[610]
#define SWIGTYPE_p_InterpolatedDefaultDensityCurveT_Linear_t swig_types[611]
#define SWIGTYPE_p_InterpolatedDiscountCurveT_KrugerLog_t swig_types[612]
#define SWIGTYPE_p_InterpolatedDiscountCurveT_LogLinear_t swig_types[613]
#define SWIGTYPE_p_InterpolatedDiscountCurveT_LogMixedLinearCubic_t swig_types[614]
#define SWIGTYPE_p_InterpolatedDiscountCurveT_MonotonicLogCubic_t swig_types[615]
#define SWIGTYPE_p_InterpolatedDiscountCurveT_SplineCubic_t swig_types[616]
#define SWIGTYPE_p_InterpolatedDiscountCurveT_SplineLogCubic_t swig_types[617]
#define SWIGTYPE_p_InterpolatedForwardCurveT_BackwardFlat_t swig_types[618]
#define SWIGTYPE_p_InterpolatedHazardRateCurveT_BackwardFlat_t swig_types[619]
#define SWIGTYPE_p_InterpolatedSmileSectionT_Cubic_t swig_types[620]
#define SWIGTYPE_p_InterpolatedSmileSectionT_Linear_t swig_types[621]
#define SWIGTYPE_p_InterpolatedSmileSectionT_MonotonicCubic_t swig_types[622]
#define SWIGTYPE_p_InterpolatedSmileSectionT_SplineCubic_t swig_types[623]
#define SWIGTYPE_p_InterpolatedSurvivalProbabilityCurveT_Linear_t swig_types[624]
#define SWIGTYPE_p_InterpolatedSwaptionVolatilityCube swig_types[625]
#define SWIGTYPE_p_InterpolatedYoYInflationCurveT_Linear_t swig_types[626]
#define SWIGTYPE_p_InterpolatedYoYOptionletStripperT_Linear_t swig_types[627]
#define SWIGTYPE_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_t swig_types[628]
#define SWIGTYPE_p_InterpolatedZeroCurveT_Cubic_t swig_types[629]
#define SWIGTYPE_p_InterpolatedZeroCurveT_DefaultLogCubic_t swig_types[630]
#define SWIGTYPE_p_InterpolatedZeroCurveT_Kruger_t swig_types[631]
#define SWIGTYPE_p_InterpolatedZeroCurveT_Linear_t swig_types[632]
#define SWIGTYPE_p_InterpolatedZeroCurveT_LogLinear_t swig_types[633]
#define SWIGTYPE_p_InterpolatedZeroCurveT_MonotonicCubic_t swig_types[634]
#define SWIGTYPE_p_InterpolatedZeroCurveT_SplineCubic_t swig_types[635]
#define SWIGTYPE_p_InterpolatedZeroInflationCurveT_Linear_t swig_types[636]
#define SWIGTYPE_p_IntervalPrice swig_types[637]
#define SWIGTYPE_p_InverseCumulativeNormal swig_types[638]
#define SWIGTYPE_p_InverseCumulativePoisson swig_types[639]
#define SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t swig_types[640]
#define SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t swig_types[641]
#define SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t swig_types[642]
#define SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t swig_types[643]
#define SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t swig_types[644]
#define SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t swig_types[645]
#define SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_InverseCumulativeNormal_t swig_types[646]
#define SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_MoroInverseCumulativeNormal_t swig_types[647]
#define SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t swig_types[648]
#define SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t swig_types[649]
#define SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t swig_types[650]
#define SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t swig_types[651]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t swig_types[652]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t swig_types[653]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t swig_types[654]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t swig_types[655]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t swig_types[656]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t swig_types[657]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t swig_types[658]
#define SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t swig_types[659]
#define SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t swig_types[660]
#define SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t swig_types[661]
#define SWIGTYPE_p_InverseCumulativeStudent swig_types[662]
#define SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution swig_types[663]
#define SWIGTYPE_p_IsdaCdsEngine swig_types[664]
#define SWIGTYPE_p_JPYLibor swig_types[665]
#define SWIGTYPE_p_JamshidianSwaptionEngine swig_types[666]
#define SWIGTYPE_p_Jibar swig_types[667]
#define SWIGTYPE_p_JpyLiborSwapIsdaFixAm swig_types[668]
#define SWIGTYPE_p_JpyLiborSwapIsdaFixPm swig_types[669]
#define SWIGTYPE_p_JuQuadraticApproximationEngine swig_types[670]
#define SWIGTYPE_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t swig_types[671]
#define SWIGTYPE_p_KahaleSmileSection swig_types[672]
#define SWIGTYPE_p_KerkhofSeasonality swig_types[673]
#define SWIGTYPE_p_KirkEngine swig_types[674]
#define SWIGTYPE_p_KirkSpreadOptionEngine swig_types[675]
#define SWIGTYPE_p_KlugeExtOUProcess swig_types[676]
#define SWIGTYPE_p_KnuthUniformRng swig_types[677]
#define SWIGTYPE_p_Kruger swig_types[678]
#define SWIGTYPE_p_KrugerLog swig_types[679]
#define SWIGTYPE_p_LMMCurveState swig_types[680]
#define SWIGTYPE_p_LMMDriftCalculator swig_types[681]
#define SWIGTYPE_p_LastFixingQuote swig_types[682]
#define SWIGTYPE_p_LazyObject swig_types[683]
#define SWIGTYPE_p_LecuyerUniformRng swig_types[684]
#define SWIGTYPE_p_LevenbergMarquardt swig_types[685]
#define SWIGTYPE_p_Libor swig_types[686]
#define SWIGTYPE_p_Linear swig_types[687]
#define SWIGTYPE_p_LinearTsrPricer swig_types[688]
#define SWIGTYPE_p_LinearTsrPricer__Settings swig_types[689]
#define SWIGTYPE_p_LocalConstantVol swig_types[690]
#define SWIGTYPE_p_LocalVolRNDCalculator swig_types[691]
#define SWIGTYPE_p_LocalVolSurface swig_types[692]
#define SWIGTYPE_p_LocalVolTermStructure swig_types[693]
#define SWIGTYPE_p_LogLinear swig_types[694]
#define SWIGTYPE_p_LogMixedLinearCubic swig_types[695]
#define SWIGTYPE_p_LogNormalFwdRateIpc swig_types[696]
#define SWIGTYPE_p_LogNormalSimulatedAnnealing swig_types[697]
#define SWIGTYPE_p_LognormalCmsSpreadPricer swig_types[698]
#define SWIGTYPE_p_LsmBasisSystem swig_types[699]
#define SWIGTYPE_p_MCAmericanBasketEngineT_LowDiscrepancy_t swig_types[700]
#define SWIGTYPE_p_MCAmericanBasketEngineT_PseudoRandom_t swig_types[701]
#define SWIGTYPE_p_MCAmericanEngineT_LowDiscrepancy_t swig_types[702]
#define SWIGTYPE_p_MCAmericanEngineT_PseudoRandom_t swig_types[703]
#define SWIGTYPE_p_MCBarrierEngineT_LowDiscrepancy_t swig_types[704]
#define SWIGTYPE_p_MCBarrierEngineT_PseudoRandom_t swig_types[705]
#define SWIGTYPE_p_MCDigitalEngineT_LowDiscrepancy_t swig_types[706]
#define SWIGTYPE_p_MCDigitalEngineT_PseudoRandom_t swig_types[707]
#define SWIGTYPE_p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t swig_types[708]
#define SWIGTYPE_p_MCDiscreteArithmeticAPEngineT_PseudoRandom_t swig_types[709]
#define SWIGTYPE_p_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t swig_types[710]
#define SWIGTYPE_p_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t swig_types[711]
#define SWIGTYPE_p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t swig_types[712]
#define SWIGTYPE_p_MCDiscreteArithmeticASEngineT_PseudoRandom_t swig_types[713]
#define SWIGTYPE_p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t swig_types[714]
#define SWIGTYPE_p_MCDiscreteGeometricAPEngineT_PseudoRandom_t swig_types[715]
#define SWIGTYPE_p_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t swig_types[716]
#define SWIGTYPE_p_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t swig_types[717]
#define SWIGTYPE_p_MCEuropeanBasketEngineT_LowDiscrepancy_t swig_types[718]
#define SWIGTYPE_p_MCEuropeanBasketEngineT_PseudoRandom_t swig_types[719]
#define SWIGTYPE_p_MCEuropeanEngineT_LowDiscrepancy_t swig_types[720]
#define SWIGTYPE_p_MCEuropeanEngineT_PseudoRandom_t swig_types[721]
#define SWIGTYPE_p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t swig_types[722]
#define SWIGTYPE_p_MCEuropeanGJRGARCHEngineT_PseudoRandom_t swig_types[723]
#define SWIGTYPE_p_MCEuropeanHestonEngineT_LowDiscrepancy_t swig_types[724]
#define SWIGTYPE_p_MCEuropeanHestonEngineT_PseudoRandom_t swig_types[725]
#define SWIGTYPE_p_MCEverestEngineT_LowDiscrepancy_t swig_types[726]
#define SWIGTYPE_p_MCEverestEngineT_PseudoRandom_t swig_types[727]
#define SWIGTYPE_p_MCForwardEuropeanBSEngineT_LowDiscrepancy_t swig_types[728]
#define SWIGTYPE_p_MCForwardEuropeanBSEngineT_PseudoRandom_t swig_types[729]
#define SWIGTYPE_p_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t swig_types[730]
#define SWIGTYPE_p_MCForwardEuropeanHestonEngineT_PseudoRandom_t swig_types[731]
#define SWIGTYPE_p_MCHimalayaEngineT_LowDiscrepancy_t swig_types[732]
#define SWIGTYPE_p_MCHimalayaEngineT_PseudoRandom_t swig_types[733]
#define SWIGTYPE_p_MCPerformanceEngineT_LowDiscrepancy_t swig_types[734]
#define SWIGTYPE_p_MCPerformanceEngineT_PseudoRandom_t swig_types[735]
#define SWIGTYPE_p_MTBrownianGenerator swig_types[736]
#define SWIGTYPE_p_MTBrownianGeneratorFactory swig_types[737]
#define SWIGTYPE_p_MakeOIS swig_types[738]
#define SWIGTYPE_p_MakeSchedule swig_types[739]
#define SWIGTYPE_p_MakeVanillaSwap swig_types[740]
#define SWIGTYPE_p_MargrabeOption swig_types[741]
#define SWIGTYPE_p_MarketModel swig_types[742]
#define SWIGTYPE_p_MarketModelEvolver swig_types[743]
#define SWIGTYPE_p_MarketModelFactory swig_types[744]
#define SWIGTYPE_p_MarkovFunctional swig_types[745]
#define SWIGTYPE_p_MarkovFunctional__ModelSettings swig_types[746]
#define SWIGTYPE_p_Matrix swig_types[747]
#define SWIGTYPE_p_MatrixMultiplicationProxy swig_types[748]
#define SWIGTYPE_p_MatrixRow swig_types[749]
#define SWIGTYPE_p_MaxBasketPayoff swig_types[750]
#define SWIGTYPE_p_MersenneTwisterUniformRng swig_types[751]
#define SWIGTYPE_p_Merton76Process swig_types[752]
#define SWIGTYPE_p_MethodOfLinesScheme swig_types[753]
#define SWIGTYPE_p_MidPointCdsEngine swig_types[754]
#define SWIGTYPE_p_MinBasketPayoff swig_types[755]
#define SWIGTYPE_p_MirrorGaussianSimulatedAnnealing swig_types[756]
#define SWIGTYPE_p_MixedInterpolation swig_types[757]
#define SWIGTYPE_p_ModifiedCraigSneydScheme swig_types[758]
#define SWIGTYPE_p_Money swig_types[759]
#define SWIGTYPE_p_MonotonicCubic swig_types[760]
#define SWIGTYPE_p_MonotonicLogCubic swig_types[761]
#define SWIGTYPE_p_MoroInverseCumulativeNormal swig_types[762]
#define SWIGTYPE_p_Mosprime swig_types[763]
#define SWIGTYPE_p_MtMCrossCurrencyBasisSwapRateHelper swig_types[764]
#define SWIGTYPE_p_MultiAssetOption swig_types[765]
#define SWIGTYPE_p_MultiPath swig_types[766]
#define SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t swig_types[767]
#define SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t swig_types[768]
#define SWIGTYPE_p_MultiplicativePriceSeasonality swig_types[769]
#define SWIGTYPE_p_NZDLibor swig_types[770]
#define SWIGTYPE_p_NelsonSiegelFitting swig_types[771]
#define SWIGTYPE_p_NeumannBC swig_types[772]
#define SWIGTYPE_p_Newton swig_types[773]
#define SWIGTYPE_p_NewtonSafe swig_types[774]
#define SWIGTYPE_p_NinePointLinearOp swig_types[775]
#define SWIGTYPE_p_NoArbSabrInterpolatedSmileSection swig_types[776]
#define SWIGTYPE_p_NoArbSabrSmileSection swig_types[777]
#define SWIGTYPE_p_NoConstraint swig_types[778]
#define SWIGTYPE_p_NoExceptLocalVolSurface swig_types[779]
#define SWIGTYPE_p_NonCentralCumulativeChiSquareDistribution swig_types[780]
#define SWIGTYPE_p_NonhomogeneousBoundaryConstraint swig_types[781]
#define SWIGTYPE_p_NonstandardSwap swig_types[782]
#define SWIGTYPE_p_NonstandardSwaption swig_types[783]
#define SWIGTYPE_p_NormalDistribution swig_types[784]
#define SWIGTYPE_p_NthOrderDerivativeOp swig_types[785]
#define SWIGTYPE_p_NullParameter swig_types[786]
#define SWIGTYPE_p_NumericHaganPricer swig_types[787]
#define SWIGTYPE_p_Nzocr swig_types[788]
#define SWIGTYPE_p_OISRateHelper swig_types[789]
#define SWIGTYPE_p_Observable swig_types[790]
#define SWIGTYPE_p_OneAssetOption swig_types[791]
#define SWIGTYPE_p_OneFactorAffineModel swig_types[792]
#define SWIGTYPE_p_OptimizationMethod swig_types[793]
#define SWIGTYPE_p_Optimizer swig_types[794]
#define SWIGTYPE_p_Option swig_types[795]
#define SWIGTYPE_p_OptionletStripper1 swig_types[796]
#define SWIGTYPE_p_OptionletVolatilityStructure swig_types[797]
#define SWIGTYPE_p_OrnsteinUhlenbeckProcess swig_types[798]
#define SWIGTYPE_p_OvernightIborBasisSwapRateHelper swig_types[799]
#define SWIGTYPE_p_OvernightIndex swig_types[800]
#define SWIGTYPE_p_OvernightIndexFuture swig_types[801]
#define SWIGTYPE_p_OvernightIndexFutureRateHelper swig_types[802]
#define SWIGTYPE_p_OvernightIndexedCoupon swig_types[803]
#define SWIGTYPE_p_OvernightIndexedSwap swig_types[804]
#define SWIGTYPE_p_OvernightIndexedSwapIndex swig_types[805]
#define SWIGTYPE_p_Parameter swig_types[806]
#define SWIGTYPE_p_ParkinsonSigma swig_types[807]
#define SWIGTYPE_p_PartialBarrier swig_types[808]
#define SWIGTYPE_p_PartialTimeBarrierOption swig_types[809]
#define SWIGTYPE_p_Path swig_types[810]
#define SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t swig_types[811]
#define SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t swig_types[812]
#define SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t swig_types[813]
#define SWIGTYPE_p_Payoff swig_types[814]
#define SWIGTYPE_p_PercentageStrikePayoff swig_types[815]
#define SWIGTYPE_p_Period swig_types[816]
#define SWIGTYPE_p_PeriodParser swig_types[817]
#define SWIGTYPE_p_PiecewiseConstantCorrelation swig_types[818]
#define SWIGTYPE_p_PiecewiseConstantParameter swig_types[819]
#define SWIGTYPE_p_PiecewiseConvexMonotoneForward swig_types[820]
#define SWIGTYPE_p_PiecewiseConvexMonotoneZero swig_types[821]
#define SWIGTYPE_p_PiecewiseCubicZero swig_types[822]
#define SWIGTYPE_p_PiecewiseFlatForward swig_types[823]
#define SWIGTYPE_p_PiecewiseFlatHazardRate swig_types[824]
#define SWIGTYPE_p_PiecewiseKrugerLogDiscount swig_types[825]
#define SWIGTYPE_p_PiecewiseKrugerZero swig_types[826]
#define SWIGTYPE_p_PiecewiseLinearForward swig_types[827]
#define SWIGTYPE_p_PiecewiseLinearZero swig_types[828]
#define SWIGTYPE_p_PiecewiseLogCubicDiscount swig_types[829]
#define SWIGTYPE_p_PiecewiseLogLinearDiscount swig_types[830]
#define SWIGTYPE_p_PiecewiseLogMixedLinearCubicDiscount swig_types[831]
#define SWIGTYPE_p_PiecewiseNaturalCubicZero swig_types[832]
#define SWIGTYPE_p_PiecewiseNaturalLogCubicDiscount swig_types[833]
#define SWIGTYPE_p_PiecewiseSplineCubicDiscount swig_types[834]
#define SWIGTYPE_p_PiecewiseTimeDependentHestonModel swig_types[835]
#define SWIGTYPE_p_PiecewiseYoYInflationCurveT_Linear_t swig_types[836]
#define SWIGTYPE_p_PiecewiseZeroInflationCurveT_Linear_t swig_types[837]
#define SWIGTYPE_p_PiecewiseZeroSpreadedTermStructure swig_types[838]
#define SWIGTYPE_p_Pillar swig_types[839]
#define SWIGTYPE_p_PlainVanillaPayoff swig_types[840]
#define SWIGTYPE_p_PoissonDistribution swig_types[841]
#define SWIGTYPE_p_Position swig_types[842]
#define SWIGTYPE_p_PositiveConstraint swig_types[843]
#define SWIGTYPE_p_Predefined1dMesher swig_types[844]
#define SWIGTYPE_p_Pribor swig_types[845]
#define SWIGTYPE_p_PricingEngine swig_types[846]
#define SWIGTYPE_p_ProbabilityBoltzmannDownhill swig_types[847]
#define SWIGTYPE_p_Protection swig_types[848]
#define SWIGTYPE_p_PyObserver swig_types[849]
#define SWIGTYPE_p_QdFpAmericanEngine swig_types[850]
#define SWIGTYPE_p_QdFpIterationScheme swig_types[851]
#define SWIGTYPE_p_QdFpLegendreScheme swig_types[852]
#define SWIGTYPE_p_QdFpLegendreTanhSinhScheme swig_types[853]
#define SWIGTYPE_p_QdFpTanhSinhIterationScheme swig_types[854]
#define SWIGTYPE_p_QdPlusAmericanEngine swig_types[855]
#define SWIGTYPE_p_QuantLib__AEDCurrency swig_types[856]
#define SWIGTYPE_p_QuantLib__AOACurrency swig_types[857]
#define SWIGTYPE_p_QuantLib__ARSCurrency swig_types[858]
#define SWIGTYPE_p_QuantLib__ATSCurrency swig_types[859]
#define SWIGTYPE_p_QuantLib__AUDCurrency swig_types[860]
#define SWIGTYPE_p_QuantLib__Actual360 swig_types[861]
#define SWIGTYPE_p_QuantLib__Actual364 swig_types[862]
#define SWIGTYPE_p_QuantLib__Actual36525 swig_types[863]
#define SWIGTYPE_p_QuantLib__Actual365Fixed swig_types[864]
#define SWIGTYPE_p_QuantLib__Actual366 swig_types[865]
#define SWIGTYPE_p_QuantLib__ActualActual swig_types[866]
#define SWIGTYPE_p_QuantLib__Argentina swig_types[867]
#define SWIGTYPE_p_QuantLib__Australia swig_types[868]
#define SWIGTYPE_p_QuantLib__Austria swig_types[869]
#define SWIGTYPE_p_QuantLib__BCHCurrency swig_types[870]
#define SWIGTYPE_p_QuantLib__BDTCurrency swig_types[871]
#define SWIGTYPE_p_QuantLib__BEFCurrency swig_types[872]
#define SWIGTYPE_p_QuantLib__BGLCurrency swig_types[873]
#define SWIGTYPE_p_QuantLib__BGNCurrency swig_types[874]
#define SWIGTYPE_p_QuantLib__BHDCurrency swig_types[875]
#define SWIGTYPE_p_QuantLib__BRLCurrency swig_types[876]
#define SWIGTYPE_p_QuantLib__BTCCurrency swig_types[877]
#define SWIGTYPE_p_QuantLib__BWPCurrency swig_types[878]
#define SWIGTYPE_p_QuantLib__BYRCurrency swig_types[879]
#define SWIGTYPE_p_QuantLib__BespokeCalendar swig_types[880]
#define SWIGTYPE_p_QuantLib__Botswana swig_types[881]
#define SWIGTYPE_p_QuantLib__Brazil swig_types[882]
#define SWIGTYPE_p_QuantLib__Business252 swig_types[883]
#define SWIGTYPE_p_QuantLib__CADCurrency swig_types[884]
#define SWIGTYPE_p_QuantLib__CHFCurrency swig_types[885]
#define SWIGTYPE_p_QuantLib__CLFCurrency swig_types[886]
#define SWIGTYPE_p_QuantLib__CLPCurrency swig_types[887]
#define SWIGTYPE_p_QuantLib__CNHCurrency swig_types[888]
#define SWIGTYPE_p_QuantLib__CNYCurrency swig_types[889]
#define SWIGTYPE_p_QuantLib__COPCurrency swig_types[890]
#define SWIGTYPE_p_QuantLib__COUCurrency swig_types[891]
#define SWIGTYPE_p_QuantLib__CYPCurrency swig_types[892]
#define SWIGTYPE_p_QuantLib__CZKCurrency swig_types[893]
#define SWIGTYPE_p_QuantLib__Canada swig_types[894]
#define SWIGTYPE_p_QuantLib__Chile swig_types[895]
#define SWIGTYPE_p_QuantLib__China swig_types[896]
#define SWIGTYPE_p_QuantLib__CzechRepublic swig_types[897]
#define SWIGTYPE_p_QuantLib__DASHCurrency swig_types[898]
#define SWIGTYPE_p_QuantLib__DEMCurrency swig_types[899]
#define SWIGTYPE_p_QuantLib__DKKCurrency swig_types[900]
#define SWIGTYPE_p_QuantLib__Denmark swig_types[901]
#define SWIGTYPE_p_QuantLib__EEKCurrency swig_types[902]
#define SWIGTYPE_p_QuantLib__EGPCurrency swig_types[903]
#define SWIGTYPE_p_QuantLib__ESPCurrency swig_types[904]
#define SWIGTYPE_p_QuantLib__ETBCurrency swig_types[905]
#define SWIGTYPE_p_QuantLib__ETCCurrency swig_types[906]
#define SWIGTYPE_p_QuantLib__ETHCurrency swig_types[907]
#define SWIGTYPE_p_QuantLib__EURCurrency swig_types[908]
#define SWIGTYPE_p_QuantLib__FIMCurrency swig_types[909]
#define SWIGTYPE_p_QuantLib__FRFCurrency swig_types[910]
#define SWIGTYPE_p_QuantLib__Finland swig_types[911]
#define SWIGTYPE_p_QuantLib__France swig_types[912]
#define SWIGTYPE_p_QuantLib__GBPCurrency swig_types[913]
#define SWIGTYPE_p_QuantLib__GELCurrency swig_types[914]
#define SWIGTYPE_p_QuantLib__GHSCurrency swig_types[915]
#define SWIGTYPE_p_QuantLib__GRDCurrency swig_types[916]
#define SWIGTYPE_p_QuantLib__Germany swig_types[917]
#define SWIGTYPE_p_QuantLib__HKDCurrency swig_types[918]
#define SWIGTYPE_p_QuantLib__HRKCurrency swig_types[919]
#define SWIGTYPE_p_QuantLib__HUFCurrency swig_types[920]
#define SWIGTYPE_p_QuantLib__HongKong swig_types[921]
#define SWIGTYPE_p_QuantLib__Hungary swig_types[922]
#define SWIGTYPE_p_QuantLib__IDRCurrency swig_types[923]
#define SWIGTYPE_p_QuantLib__IEPCurrency swig_types[924]
#define SWIGTYPE_p_QuantLib__ILSCurrency swig_types[925]
#define SWIGTYPE_p_QuantLib__INRCurrency swig_types[926]
#define SWIGTYPE_p_QuantLib__IQDCurrency swig_types[927]
#define SWIGTYPE_p_QuantLib__IRRCurrency swig_types[928]
#define SWIGTYPE_p_QuantLib__ISKCurrency swig_types[929]
#define SWIGTYPE_p_QuantLib__ITLCurrency swig_types[930]
#define SWIGTYPE_p_QuantLib__Iceland swig_types[931]
#define SWIGTYPE_p_QuantLib__India swig_types[932]
#define SWIGTYPE_p_QuantLib__Indonesia swig_types[933]
#define SWIGTYPE_p_QuantLib__Israel swig_types[934]
#define SWIGTYPE_p_QuantLib__Italy swig_types[935]
#define SWIGTYPE_p_QuantLib__JODCurrency swig_types[936]
#define SWIGTYPE_p_QuantLib__JPYCurrency swig_types[937]
#define SWIGTYPE_p_QuantLib__Japan swig_types[938]
#define SWIGTYPE_p_QuantLib__JointCalendar swig_types[939]
#define SWIGTYPE_p_QuantLib__KESCurrency swig_types[940]
#define SWIGTYPE_p_QuantLib__KRWCurrency swig_types[941]
#define SWIGTYPE_p_QuantLib__KWDCurrency swig_types[942]
#define SWIGTYPE_p_QuantLib__KZTCurrency swig_types[943]
#define SWIGTYPE_p_QuantLib__LKRCurrency swig_types[944]
#define SWIGTYPE_p_QuantLib__LTCCurrency swig_types[945]
#define SWIGTYPE_p_QuantLib__LTLCurrency swig_types[946]
#define SWIGTYPE_p_QuantLib__LUFCurrency swig_types[947]
#define SWIGTYPE_p_QuantLib__LVLCurrency swig_types[948]
#define SWIGTYPE_p_QuantLib__MADCurrency swig_types[949]
#define SWIGTYPE_p_QuantLib__MTLCurrency swig_types[950]
#define SWIGTYPE_p_QuantLib__MURCurrency swig_types[951]
#define SWIGTYPE_p_QuantLib__MXNCurrency swig_types[952]
#define SWIGTYPE_p_QuantLib__MXVCurrency swig_types[953]
#define SWIGTYPE_p_QuantLib__MYRCurrency swig_types[954]
#define SWIGTYPE_p_QuantLib__Mexico swig_types[955]
#define SWIGTYPE_p_QuantLib__NGNCurrency swig_types[956]
#define SWIGTYPE_p_QuantLib__NLGCurrency swig_types[957]
#define SWIGTYPE_p_QuantLib__NOKCurrency swig_types[958]
#define SWIGTYPE_p_QuantLib__NPRCurrency swig_types[959]
#define SWIGTYPE_p_QuantLib__NZDCurrency swig_types[960]
#define SWIGTYPE_p_QuantLib__NewZealand swig_types[961]
#define SWIGTYPE_p_QuantLib__Norway swig_types[962]
#define SWIGTYPE_p_QuantLib__NullCalendar swig_types[963]
#define SWIGTYPE_p_QuantLib__OMRCurrency swig_types[964]
#define SWIGTYPE_p_QuantLib__OneDayCounter swig_types[965]
#define SWIGTYPE_p_QuantLib__PEHCurrency swig_types[966]
#define SWIGTYPE_p_QuantLib__PEICurrency swig_types[967]
#define SWIGTYPE_p_QuantLib__PENCurrency swig_types[968]
#define SWIGTYPE_p_QuantLib__PHPCurrency swig_types[969]
#define SWIGTYPE_p_QuantLib__PKRCurrency swig_types[970]
#define SWIGTYPE_p_QuantLib__PLNCurrency swig_types[971]
#define SWIGTYPE_p_QuantLib__PTECurrency swig_types[972]
#define SWIGTYPE_p_QuantLib__Poland swig_types[973]
#define SWIGTYPE_p_QuantLib__QARCurrency swig_types[974]
#define SWIGTYPE_p_QuantLib__ROLCurrency swig_types[975]
#define SWIGTYPE_p_QuantLib__RONCurrency swig_types[976]
#define SWIGTYPE_p_QuantLib__RSDCurrency swig_types[977]
#define SWIGTYPE_p_QuantLib__RUBCurrency swig_types[978]
#define SWIGTYPE_p_QuantLib__Romania swig_types[979]
#define SWIGTYPE_p_QuantLib__Russia swig_types[980]
#define SWIGTYPE_p_QuantLib__SARCurrency swig_types[981]
#define SWIGTYPE_p_QuantLib__SEKCurrency swig_types[982]
#define SWIGTYPE_p_QuantLib__SGDCurrency swig_types[983]
#define SWIGTYPE_p_QuantLib__SITCurrency swig_types[984]
#define SWIGTYPE_p_QuantLib__SKKCurrency swig_types[985]
#define SWIGTYPE_p_QuantLib__SaudiArabia swig_types[986]
#define SWIGTYPE_p_QuantLib__SimpleDayCounter swig_types[987]
#define SWIGTYPE_p_QuantLib__Singapore swig_types[988]
#define SWIGTYPE_p_QuantLib__Slovakia swig_types[989]
#define SWIGTYPE_p_QuantLib__SouthAfrica swig_types[990]
#define SWIGTYPE_p_QuantLib__SouthKorea swig_types[991]
#define SWIGTYPE_p_QuantLib__Sweden swig_types[992]
#define SWIGTYPE_p_QuantLib__Switzerland swig_types[993]
#define SWIGTYPE_p_QuantLib__TARGET swig_types[994]
#define SWIGTYPE_p_QuantLib__THBCurrency swig_types[995]
#define SWIGTYPE_p_QuantLib__TNDCurrency swig_types[996]
#define SWIGTYPE_p_QuantLib__TRLCurrency swig_types[997]
#define SWIGTYPE_p_QuantLib__TRYCurrency swig_types[998]
#define SWIGTYPE_p_QuantLib__TTDCurrency swig_types[999]
#define SWIGTYPE_p_QuantLib__TWDCurrency swig_types[1000]
#define SWIGTYPE_p_QuantLib__Taiwan swig_types[1001]
#define SWIGTYPE_p_QuantLib__Thailand swig_types[1002]
#define SWIGTYPE_p_QuantLib__Thirty360 swig_types[1003]
#define SWIGTYPE_p_QuantLib__Thirty365 swig_types[1004]
#define SWIGTYPE_p_QuantLib__Turkey swig_types[1005]
#define SWIGTYPE_p_QuantLib__UAHCurrency swig_types[1006]
#define SWIGTYPE_p_QuantLib__UGXCurrency swig_types[1007]
#define SWIGTYPE_p_QuantLib__USDCurrency swig_types[1008]
#define SWIGTYPE_p_QuantLib__UYUCurrency swig_types[1009]
#define SWIGTYPE_p_QuantLib__Ukraine swig_types[1010]
#define SWIGTYPE_p_QuantLib__UnitedKingdom swig_types[1011]
#define SWIGTYPE_p_QuantLib__UnitedStates swig_types[1012]
#define SWIGTYPE_p_QuantLib__VEBCurrency swig_types[1013]
#define SWIGTYPE_p_QuantLib__VNDCurrency swig_types[1014]
#define SWIGTYPE_p_QuantLib__WeekendsOnly swig_types[1015]
#define SWIGTYPE_p_QuantLib__XOFCurrency swig_types[1016]
#define SWIGTYPE_p_QuantLib__XRPCurrency swig_types[1017]
#define SWIGTYPE_p_QuantLib__ZARCurrency swig_types[1018]
#define SWIGTYPE_p_QuantLib__ZECCurrency swig_types[1019]
#define SWIGTYPE_p_QuantLib__ZMWCurrency swig_types[1020]
#define SWIGTYPE_p_QuantoBarrierEngine swig_types[1021]
#define SWIGTYPE_p_QuantoBarrierOption swig_types[1022]
#define SWIGTYPE_p_QuantoDoubleBarrierOption swig_types[1023]
#define SWIGTYPE_p_QuantoEuropeanEngine swig_types[1024]
#define SWIGTYPE_p_QuantoForwardEuropeanEngine swig_types[1025]
#define SWIGTYPE_p_QuantoForwardVanillaOption swig_types[1026]
#define SWIGTYPE_p_QuantoTermStructure swig_types[1027]
#define SWIGTYPE_p_QuantoVanillaOption swig_types[1028]
#define SWIGTYPE_p_Quote swig_types[1029]
#define SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t swig_types[1030]
#define SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t swig_types[1031]
#define SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t swig_types[1032]
#define SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t swig_types[1033]
#define SWIGTYPE_p_RateAveraging swig_types[1034]
#define SWIGTYPE_p_RateHelper swig_types[1035]
#define SWIGTYPE_p_RealTimeSeries swig_types[1036]
#define SWIGTYPE_p_ReannealingTrivial swig_types[1037]
#define SWIGTYPE_p_RebatedExercise swig_types[1038]
#define SWIGTYPE_p_Redemption swig_types[1039]
#define SWIGTYPE_p_Region swig_types[1040]
#define SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t swig_types[1041]
#define SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t swig_types[1042]
#define SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t swig_types[1043]
#define SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t swig_types[1044]
#define SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t swig_types[1045]
#define SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t swig_types[1046]
#define SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t swig_types[1047]
#define SWIGTYPE_p_RelinkableHandleT_Quote_t swig_types[1048]
#define SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t swig_types[1049]
#define SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t swig_types[1050]
#define SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t swig_types[1051]
#define SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t swig_types[1052]
#define SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t swig_types[1053]
#define SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t swig_types[1054]
#define SWIGTYPE_p_RichardsonExtrapolation swig_types[1055]
#define SWIGTYPE_p_Ridder swig_types[1056]
#define SWIGTYPE_p_RiskNeutralDensityCalculator swig_types[1057]
#define SWIGTYPE_p_RiskStatistics swig_types[1058]
#define SWIGTYPE_p_RiskyBondEngine swig_types[1059]
#define SWIGTYPE_p_Robor swig_types[1060]
#define SWIGTYPE_p_Rounding swig_types[1061]
#define SWIGTYPE_p_SEKLibor swig_types[1062]
#define SWIGTYPE_p_SVD swig_types[1063]
#define SWIGTYPE_p_SabrSmileSection swig_types[1064]
#define SWIGTYPE_p_SabrSwaptionVolatilityCube swig_types[1065]
#define SWIGTYPE_p_SafeBackwardFlatInterpolation swig_types[1066]
#define SWIGTYPE_p_SafeBicubicSpline swig_types[1067]
#define SWIGTYPE_p_SafeBilinearInterpolation swig_types[1068]
#define SWIGTYPE_p_SafeConvexMonotoneInterpolation swig_types[1069]
#define SWIGTYPE_p_SafeCubicNaturalSpline swig_types[1070]
#define SWIGTYPE_p_SafeForwardFlatInterpolation swig_types[1071]
#define SWIGTYPE_p_SafeFritschButlandCubic swig_types[1072]
#define SWIGTYPE_p_SafeFritschButlandLogCubic swig_types[1073]
#define SWIGTYPE_p_SafeKrugerCubic swig_types[1074]
#define SWIGTYPE_p_SafeKrugerLogCubic swig_types[1075]
#define SWIGTYPE_p_SafeLagrangeInterpolation swig_types[1076]
#define SWIGTYPE_p_SafeLinearInterpolation swig_types[1077]
#define SWIGTYPE_p_SafeLogCubicNaturalSpline swig_types[1078]
#define SWIGTYPE_p_SafeLogLinearInterpolation swig_types[1079]
#define SWIGTYPE_p_SafeLogParabolic swig_types[1080]
#define SWIGTYPE_p_SafeMonotonicCubicNaturalSpline swig_types[1081]
#define SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline swig_types[1082]
#define SWIGTYPE_p_SafeMonotonicLogParabolic swig_types[1083]
#define SWIGTYPE_p_SafeMonotonicParabolic swig_types[1084]
#define SWIGTYPE_p_SafeParabolic swig_types[1085]
#define SWIGTYPE_p_SafeSABRInterpolation swig_types[1086]
#define SWIGTYPE_p_SalvagingAlgorithm swig_types[1087]
#define SWIGTYPE_p_SampleT_Array_t swig_types[1088]
#define SWIGTYPE_p_SampleT_MultiPath_t swig_types[1089]
#define SWIGTYPE_p_SampleT_Path_t swig_types[1090]
#define SWIGTYPE_p_SampleT_double_t swig_types[1091]
#define SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[1092]
#define SWIGTYPE_p_SampledCurve swig_types[1093]
#define SWIGTYPE_p_SamplerGaussian swig_types[1094]
#define SWIGTYPE_p_SamplerLogNormal swig_types[1095]
#define SWIGTYPE_p_SamplerMirrorGaussian swig_types[1096]
#define SWIGTYPE_p_Schedule swig_types[1097]
#define SWIGTYPE_p_Seasonality swig_types[1098]
#define SWIGTYPE_p_Secant swig_types[1099]
#define SWIGTYPE_p_SecondDerivativeOp swig_types[1100]
#define SWIGTYPE_p_SecondOrderMixedDerivativeOp swig_types[1101]
#define SWIGTYPE_p_SegmentIntegral swig_types[1102]
#define SWIGTYPE_p_Settings swig_types[1103]
#define SWIGTYPE_p_Settlement swig_types[1104]
#define SWIGTYPE_p_Shibor swig_types[1105]
#define SWIGTYPE_p_ShortRateModel swig_types[1106]
#define SWIGTYPE_p_Side swig_types[1107]
#define SWIGTYPE_p_SimpleCashFlow swig_types[1108]
#define SWIGTYPE_p_SimpleChooserOption swig_types[1109]
#define SWIGTYPE_p_SimplePolynomialFitting swig_types[1110]
#define SWIGTYPE_p_SimpleQuote swig_types[1111]
#define SWIGTYPE_p_Simplex swig_types[1112]
#define SWIGTYPE_p_SimpsonIntegral swig_types[1113]
#define SWIGTYPE_p_SmileSection swig_types[1114]
#define SWIGTYPE_p_SobolBrownianBridgeRsg swig_types[1115]
#define SWIGTYPE_p_SobolBrownianGenerator swig_types[1116]
#define SWIGTYPE_p_SobolBrownianGeneratorFactory swig_types[1117]
#define SWIGTYPE_p_SobolRsg swig_types[1118]
#define SWIGTYPE_p_Sofr swig_types[1119]
#define SWIGTYPE_p_SofrFutureRateHelper swig_types[1120]
#define SWIGTYPE_p_SoftCallability swig_types[1121]
#define SWIGTYPE_p_Sonia swig_types[1122]
#define SWIGTYPE_p_SparseMatrix swig_types[1123]
#define SWIGTYPE_p_SplineCubic swig_types[1124]
#define SWIGTYPE_p_SplineLogCubic swig_types[1125]
#define SWIGTYPE_p_SpreadBasketPayoff swig_types[1126]
#define SWIGTYPE_p_SpreadCdsHelper swig_types[1127]
#define SWIGTYPE_p_SpreadFittingMethod swig_types[1128]
#define SWIGTYPE_p_SpreadOption swig_types[1129]
#define SWIGTYPE_p_SpreadedBackwardFlatZeroInterpolatedTermStructure swig_types[1130]
#define SWIGTYPE_p_SpreadedLinearZeroInterpolatedTermStructure swig_types[1131]
#define SWIGTYPE_p_SquareRootProcessRNDCalculator swig_types[1132]
#define SWIGTYPE_p_Statistics swig_types[1133]
#define SWIGTYPE_p_SteepestDescent swig_types[1134]
#define SWIGTYPE_p_StepConditionT_Array_t swig_types[1135]
#define SWIGTYPE_p_StochasticProcess swig_types[1136]
#define SWIGTYPE_p_StochasticProcess1D swig_types[1137]
#define SWIGTYPE_p_StochasticProcessArray swig_types[1138]
#define SWIGTYPE_p_Stock swig_types[1139]
#define SWIGTYPE_p_StrikedTypePayoff swig_types[1140]
#define SWIGTYPE_p_StrippedOptionlet swig_types[1141]
#define SWIGTYPE_p_StrippedOptionletAdapter swig_types[1142]
#define SWIGTYPE_p_StrippedOptionletBase swig_types[1143]
#define SWIGTYPE_p_StudentDistribution swig_types[1144]
#define SWIGTYPE_p_StulzEngine swig_types[1145]
#define SWIGTYPE_p_SubPeriodsCoupon swig_types[1146]
#define SWIGTYPE_p_SubPeriodsPricer swig_types[1147]
#define SWIGTYPE_p_SuoWangDoubleBarrierEngine swig_types[1148]
#define SWIGTYPE_p_SuperSharePayoff swig_types[1149]
#define SWIGTYPE_p_SvenssonFitting swig_types[1150]
#define SWIGTYPE_p_SviInterpolatedSmileSection swig_types[1151]
#define SWIGTYPE_p_SviSmileSection swig_types[1152]
#define SWIGTYPE_p_Swap swig_types[1153]
#define SWIGTYPE_p_SwapIndex swig_types[1154]
#define SWIGTYPE_p_SwapRateHelper swig_types[1155]
#define SWIGTYPE_p_SwapSpreadIndex swig_types[1156]
#define SWIGTYPE_p_Swaption swig_types[1157]
#define SWIGTYPE_p_SwaptionHelper swig_types[1158]
#define SWIGTYPE_p_SwaptionVolatilityCube swig_types[1159]
#define SWIGTYPE_p_SwaptionVolatilityDiscrete swig_types[1160]
#define SWIGTYPE_p_SwaptionVolatilityMatrix swig_types[1161]
#define SWIGTYPE_p_SwaptionVolatilityStructure swig_types[1162]
#define SWIGTYPE_p_Swestr swig_types[1163]
#define SWIGTYPE_p_SwingExercise swig_types[1164]
#define SWIGTYPE_p_THBFIX swig_types[1165]
#define SWIGTYPE_p_TRLibor swig_types[1166]
#define SWIGTYPE_p_TanhSinhIntegral swig_types[1167]
#define SWIGTYPE_p_TemperatureExponential swig_types[1168]
#define SWIGTYPE_p_TermStructure swig_types[1169]
#define SWIGTYPE_p_TermStructureConsistentModel swig_types[1170]
#define SWIGTYPE_p_Tibor swig_types[1171]
#define SWIGTYPE_p_TimeBasket swig_types[1172]
#define SWIGTYPE_p_TimeGrid swig_types[1173]
#define SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t swig_types[1174]
#define SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t swig_types[1175]
#define SWIGTYPE_p_TrapezoidIntegralT_Default_t swig_types[1176]
#define SWIGTYPE_p_TrapezoidIntegralT_MidPoint_t swig_types[1177]
#define SWIGTYPE_p_TreeCallableFixedRateBondEngine swig_types[1178]
#define SWIGTYPE_p_TreeCapFloorEngine swig_types[1179]
#define SWIGTYPE_p_TreeSwaptionEngine swig_types[1180]
#define SWIGTYPE_p_TridiagonalOperator swig_types[1181]
#define SWIGTYPE_p_TripleBandLinearOp swig_types[1182]
#define SWIGTYPE_p_TurnbullWakemanAsianEngine swig_types[1183]
#define SWIGTYPE_p_TypePayoff swig_types[1184]
#define SWIGTYPE_p_UKHICP swig_types[1185]
#define SWIGTYPE_p_UKRPI swig_types[1186]
#define SWIGTYPE_p_USCPI swig_types[1187]
#define SWIGTYPE_p_USDLibor swig_types[1188]
#define SWIGTYPE_p_USDLiborON swig_types[1189]
#define SWIGTYPE_p_UltimateForwardTermStructure swig_types[1190]
#define SWIGTYPE_p_Uniform1dMesher swig_types[1191]
#define SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator swig_types[1192]
#define SWIGTYPE_p_UniformRandomGenerator swig_types[1193]
#define SWIGTYPE_p_UniformRandomSequenceGenerator swig_types[1194]
#define SWIGTYPE_p_UnitDisplacedBlackYoYInflationCouponPricer swig_types[1195]
#define SWIGTYPE_p_UpRounding swig_types[1196]
#define SWIGTYPE_p_UpfrontCdsHelper swig_types[1197]
#define SWIGTYPE_p_UsdLiborSwapIsdaFixAm swig_types[1198]
#define SWIGTYPE_p_UsdLiborSwapIsdaFixPm swig_types[1199]
#define SWIGTYPE_p_VanillaForwardPayoff swig_types[1200]
#define SWIGTYPE_p_VanillaOption swig_types[1201]
#define SWIGTYPE_p_VanillaSwap swig_types[1202]
#define SWIGTYPE_p_VanillaSwingOption swig_types[1203]
#define SWIGTYPE_p_VannaVolgaBarrierEngine swig_types[1204]
#define SWIGTYPE_p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t swig_types[1205]
#define SWIGTYPE_p_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t swig_types[1206]
#define SWIGTYPE_p_VarianceGammaEngine swig_types[1207]
#define SWIGTYPE_p_VarianceGammaProcess swig_types[1208]
#define SWIGTYPE_p_Vasicek swig_types[1209]
#define SWIGTYPE_p_VolatilityTermStructure swig_types[1210]
#define SWIGTYPE_p_Wibor swig_types[1211]
#define SWIGTYPE_p_Xoshiro256StarStarUniformRng swig_types[1212]
#define SWIGTYPE_p_YYEUHICP swig_types[1213]
#define SWIGTYPE_p_YYEUHICPXT swig_types[1214]
#define SWIGTYPE_p_YYEUHICPr swig_types[1215]
#define SWIGTYPE_p_YYFRHICP swig_types[1216]
#define SWIGTYPE_p_YYFRHICPr swig_types[1217]
#define SWIGTYPE_p_YYUKRPI swig_types[1218]
#define SWIGTYPE_p_YYUKRPIr swig_types[1219]
#define SWIGTYPE_p_YYUSCPI swig_types[1220]
#define SWIGTYPE_p_YYUSCPIr swig_types[1221]
#define SWIGTYPE_p_YYZACPI swig_types[1222]
#define SWIGTYPE_p_YYZACPIr swig_types[1223]
#define SWIGTYPE_p_YearOnYearInflationSwap swig_types[1224]
#define SWIGTYPE_p_YearOnYearInflationSwapHelper swig_types[1225]
#define SWIGTYPE_p_YieldTermStructure swig_types[1226]
#define SWIGTYPE_p_YoYCapFloorTermPriceSurface swig_types[1227]
#define SWIGTYPE_p_YoYInflationBachelierCapFloorEngine swig_types[1228]
#define SWIGTYPE_p_YoYInflationBlackCapFloorEngine swig_types[1229]
#define SWIGTYPE_p_YoYInflationCap swig_types[1230]
#define SWIGTYPE_p_YoYInflationCapFloor swig_types[1231]
#define SWIGTYPE_p_YoYInflationCapFloorTermPriceSurface swig_types[1232]
#define SWIGTYPE_p_YoYInflationCollar swig_types[1233]
#define SWIGTYPE_p_YoYInflationCoupon swig_types[1234]
#define SWIGTYPE_p_YoYInflationCouponPricer swig_types[1235]
#define SWIGTYPE_p_YoYInflationFloor swig_types[1236]
#define SWIGTYPE_p_YoYInflationIndex swig_types[1237]
#define SWIGTYPE_p_YoYInflationTermStructure swig_types[1238]
#define SWIGTYPE_p_YoYInflationUnitDisplacedBlackCapFloorEngine swig_types[1239]
#define SWIGTYPE_p_YoYOptionletHelper swig_types[1240]
#define SWIGTYPE_p_YoYOptionletStripper swig_types[1241]
#define SWIGTYPE_p_YoYOptionletVolatilitySurface swig_types[1242]
#define SWIGTYPE_p_ZACPI swig_types[1243]
#define SWIGTYPE_p_ZabrFullFd swig_types[1244]
#define SWIGTYPE_p_ZabrInterpolatedSmileSectionT_ZabrFullFd_t swig_types[1245]
#define SWIGTYPE_p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t swig_types[1246]
#define SWIGTYPE_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t swig_types[1247]
#define SWIGTYPE_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t swig_types[1248]
#define SWIGTYPE_p_ZabrLocalVolatility swig_types[1249]
#define SWIGTYPE_p_ZabrShortMaturityLognormal swig_types[1250]
#define SWIGTYPE_p_ZabrShortMaturityNormal swig_types[1251]
#define SWIGTYPE_p_ZabrSmileSectionT_ZabrFullFd_t swig_types[1252]
#define SWIGTYPE_p_ZabrSmileSectionT_ZabrLocalVolatility_t swig_types[1253]
#define SWIGTYPE_p_ZabrSmileSectionT_ZabrShortMaturityLognormal_t swig_types[1254]
#define SWIGTYPE_p_ZabrSmileSectionT_ZabrShortMaturityNormal_t swig_types[1255]
#define SWIGTYPE_p_ZeroCouponBond swig_types[1256]
#define SWIGTYPE_p_ZeroCouponInflationSwap swig_types[1257]
#define SWIGTYPE_p_ZeroCouponInflationSwapHelper swig_types[1258]
#define SWIGTYPE_p_ZeroCouponSwap swig_types[1259]
#define SWIGTYPE_p_ZeroInflationCashFlow swig_types[1260]
#define SWIGTYPE_p_ZeroInflationIndex swig_types[1261]
#define SWIGTYPE_p_ZeroInflationTermStructure swig_types[1262]
#define SWIGTYPE_p_ZeroSpreadedTermStructure swig_types[1263]
#define SWIGTYPE_p_ZeroYield swig_types[1264]
#define SWIGTYPE_p_Zibor swig_types[1265]
#define SWIGTYPE_p__GlobalBootstrap swig_types[1266]
#define SWIGTYPE_p__IterativeBootstrap swig_types[1267]
#define SWIGTYPE_p_allocator_type swig_types[1268]
#define SWIGTYPE_p_char swig_types[1269]
#define SWIGTYPE_p_const_reference swig_types[1270]
#define SWIGTYPE_p_difference_type swig_types[1271]
#define SWIGTYPE_p_double swig_types[1272]
#define SWIGTYPE_p_ext__functionT_double_fdoubleF_t swig_types[1273]
#define SWIGTYPE_p_ext__shared_ptrT_AUCPI_t swig_types[1274]
#define SWIGTYPE_p_ext__shared_ptrT_AUDLibor_t swig_types[1275]
#define SWIGTYPE_p_ext__shared_ptrT_AbcdVol_t swig_types[1276]
#define SWIGTYPE_p_ext__shared_ptrT_AmericanExercise_t swig_types[1277]
#define SWIGTYPE_p_ext__shared_ptrT_AmortizingCmsRateBond_t swig_types[1278]
#define SWIGTYPE_p_ext__shared_ptrT_AmortizingFixedRateBond_t swig_types[1279]
#define SWIGTYPE_p_ext__shared_ptrT_AmortizingFloatingRateBond_t swig_types[1280]
#define SWIGTYPE_p_ext__shared_ptrT_AmortizingPayment_t swig_types[1281]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticAmericanMargrabeEngine_t swig_types[1282]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t swig_types[1283]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticBarrierEngine_t swig_types[1284]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t swig_types[1285]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticCEVEngine_t swig_types[1286]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticCapFloorEngine_t swig_types[1287]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticCliquetEngine_t swig_types[1288]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticComplexChooserEngine_t swig_types[1289]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticCompoundOptionEngine_t swig_types[1290]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFixedLookbackEngine_t swig_types[1291]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFloatingLookbackEngine_t swig_types[1292]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t swig_types[1293]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_t swig_types[1294]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFixedLookbackEngine_t swig_types[1295]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFloatingLookbackEngine_t swig_types[1296]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t swig_types[1297]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t swig_types[1298]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t swig_types[1299]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_t swig_types[1300]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t swig_types[1301]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t swig_types[1302]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t swig_types[1303]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t swig_types[1304]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanEngine_t swig_types[1305]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanMargrabeEngine_t swig_types[1306]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t swig_types[1307]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticH1HWEngine_t swig_types[1308]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticHaganPricer_t swig_types[1309]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t swig_types[1310]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_t swig_types[1311]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_t swig_types[1312]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t swig_types[1313]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticPartialTimeBarrierOptionEngine_t swig_types[1314]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticPerformanceEngine_t swig_types[1315]
#define SWIGTYPE_p_ext__shared_ptrT_AnalyticSimpleChooserEngine_t swig_types[1316]
#define SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t swig_types[1317]
#define SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t swig_types[1318]
#define SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t swig_types[1319]
#define SWIGTYPE_p_ext__shared_ptrT_Aonia_t swig_types[1320]
#define SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t swig_types[1321]
#define SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t swig_types[1322]
#define SWIGTYPE_p_ext__shared_ptrT_AssetOrNothingPayoff_t swig_types[1323]
#define SWIGTYPE_p_ext__shared_ptrT_AssetSwap_t swig_types[1324]
#define SWIGTYPE_p_ext__shared_ptrT_AverageBasketPayoff_t swig_types[1325]
#define SWIGTYPE_p_ext__shared_ptrT_AveragingRatePricer_t swig_types[1326]
#define SWIGTYPE_p_ext__shared_ptrT_BFGS_t swig_types[1327]
#define SWIGTYPE_p_ext__shared_ptrT_BSMRNDCalculator_t swig_types[1328]
#define SWIGTYPE_p_ext__shared_ptrT_BachelierCapFloorEngine_t swig_types[1329]
#define SWIGTYPE_p_ext__shared_ptrT_BachelierSwaptionEngine_t swig_types[1330]
#define SWIGTYPE_p_ext__shared_ptrT_BachelierYoYInflationCouponPricer_t swig_types[1331]
#define SWIGTYPE_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t swig_types[1332]
#define SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t swig_types[1333]
#define SWIGTYPE_p_ext__shared_ptrT_BasketOption_t swig_types[1334]
#define SWIGTYPE_p_ext__shared_ptrT_BasketPayoff_t swig_types[1335]
#define SWIGTYPE_p_ext__shared_ptrT_BatesEngine_t swig_types[1336]
#define SWIGTYPE_p_ext__shared_ptrT_BatesModel_t swig_types[1337]
#define SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t swig_types[1338]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw1M_t swig_types[1339]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw2M_t swig_types[1340]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw3M_t swig_types[1341]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw4M_t swig_types[1342]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw5M_t swig_types[1343]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw6M_t swig_types[1344]
#define SWIGTYPE_p_ext__shared_ptrT_Bbsw_t swig_types[1345]
#define SWIGTYPE_p_ext__shared_ptrT_BermudanExercise_t swig_types[1346]
#define SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t swig_types[1347]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor1M_t swig_types[1348]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor1Y_t swig_types[1349]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor2M_t swig_types[1350]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor3M_t swig_types[1351]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor6M_t swig_types[1352]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor9M_t swig_types[1353]
#define SWIGTYPE_p_ext__shared_ptrT_BiborSW_t swig_types[1354]
#define SWIGTYPE_p_ext__shared_ptrT_Bibor_t swig_types[1355]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t swig_types[1356]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t swig_types[1357]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t swig_types[1358]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t swig_types[1359]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t swig_types[1360]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t swig_types[1361]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t swig_types[1362]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t swig_types[1363]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t swig_types[1364]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t swig_types[1365]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t swig_types[1366]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t swig_types[1367]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t swig_types[1368]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t swig_types[1369]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1370]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1371]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1372]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1373]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1374]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1375]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t swig_types[1376]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t swig_types[1377]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t swig_types[1378]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t swig_types[1379]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t swig_types[1380]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t swig_types[1381]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t swig_types[1382]
#define SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t swig_types[1383]
#define SWIGTYPE_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t swig_types[1384]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm1M_t swig_types[1385]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm2M_t swig_types[1386]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm3M_t swig_types[1387]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm4M_t swig_types[1388]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm5M_t swig_types[1389]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm6M_t swig_types[1390]
#define SWIGTYPE_p_ext__shared_ptrT_Bkbm_t swig_types[1391]
#define SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t swig_types[1392]
#define SWIGTYPE_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t swig_types[1393]
#define SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t swig_types[1394]
#define SWIGTYPE_p_ext__shared_ptrT_BlackCdsOptionEngine_t swig_types[1395]
#define SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t swig_types[1396]
#define SWIGTYPE_p_ext__shared_ptrT_BlackIborCouponPricer_t swig_types[1397]
#define SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t swig_types[1398]
#define SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t swig_types[1399]
#define SWIGTYPE_p_ext__shared_ptrT_BlackScholesMertonProcess_t swig_types[1400]
#define SWIGTYPE_p_ext__shared_ptrT_BlackScholesProcess_t swig_types[1401]
#define SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t swig_types[1402]
#define SWIGTYPE_p_ext__shared_ptrT_BlackVarianceCurve_t swig_types[1403]
#define SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t swig_types[1404]
#define SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t swig_types[1405]
#define SWIGTYPE_p_ext__shared_ptrT_BlackYoYInflationCouponPricer_t swig_types[1406]
#define SWIGTYPE_p_ext__shared_ptrT_BondForward_t swig_types[1407]
#define SWIGTYPE_p_ext__shared_ptrT_BondHelper_t swig_types[1408]
#define SWIGTYPE_p_ext__shared_ptrT_Bond_t swig_types[1409]
#define SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t swig_types[1410]
#define SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t swig_types[1411]
#define SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t swig_types[1412]
#define SWIGTYPE_p_ext__shared_ptrT_BoundaryConstraint_t swig_types[1413]
#define SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t swig_types[1414]
#define SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t swig_types[1415]
#define SWIGTYPE_p_ext__shared_ptrT_CADLiborON_t swig_types[1416]
#define SWIGTYPE_p_ext__shared_ptrT_CADLibor_t swig_types[1417]
#define SWIGTYPE_p_ext__shared_ptrT_CEVRNDCalculator_t swig_types[1418]
#define SWIGTYPE_p_ext__shared_ptrT_CHFLibor_t swig_types[1419]
#define SWIGTYPE_p_ext__shared_ptrT_COSHestonEngine_t swig_types[1420]
#define SWIGTYPE_p_ext__shared_ptrT_CPIBond_t swig_types[1421]
#define SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t swig_types[1422]
#define SWIGTYPE_p_ext__shared_ptrT_CPICouponPricer_t swig_types[1423]
#define SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t swig_types[1424]
#define SWIGTYPE_p_ext__shared_ptrT_CPISwap_t swig_types[1425]
#define SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t swig_types[1426]
#define SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t swig_types[1427]
#define SWIGTYPE_p_ext__shared_ptrT_Callability_t swig_types[1428]
#define SWIGTYPE_p_ext__shared_ptrT_CallableBond_t swig_types[1429]
#define SWIGTYPE_p_ext__shared_ptrT_CallableFixedRateBond_t swig_types[1430]
#define SWIGTYPE_p_ext__shared_ptrT_CallableZeroCouponBond_t swig_types[1431]
#define SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t swig_types[1432]
#define SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t swig_types[1433]
#define SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t swig_types[1434]
#define SWIGTYPE_p_ext__shared_ptrT_CapFloor_t swig_types[1435]
#define SWIGTYPE_p_ext__shared_ptrT_CapHelper_t swig_types[1436]
#define SWIGTYPE_p_ext__shared_ptrT_Cap_t swig_types[1437]
#define SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t swig_types[1438]
#define SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t swig_types[1439]
#define SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t swig_types[1440]
#define SWIGTYPE_p_ext__shared_ptrT_CappedFlooredIborCoupon_t swig_types[1441]
#define SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t swig_types[1442]
#define SWIGTYPE_p_ext__shared_ptrT_CashFlow_t swig_types[1443]
#define SWIGTYPE_p_ext__shared_ptrT_CashOrNothingPayoff_t swig_types[1444]
#define SWIGTYPE_p_ext__shared_ptrT_Cdor_t swig_types[1445]
#define SWIGTYPE_p_ext__shared_ptrT_CdsOption_t swig_types[1446]
#define SWIGTYPE_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t swig_types[1447]
#define SWIGTYPE_p_ext__shared_ptrT_Claim_t swig_types[1448]
#define SWIGTYPE_p_ext__shared_ptrT_CliquetOption_t swig_types[1449]
#define SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t swig_types[1450]
#define SWIGTYPE_p_ext__shared_ptrT_CmsCoupon_t swig_types[1451]
#define SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t swig_types[1452]
#define SWIGTYPE_p_ext__shared_ptrT_CmsRateBond_t swig_types[1453]
#define SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t swig_types[1454]
#define SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCoupon_t swig_types[1455]
#define SWIGTYPE_p_ext__shared_ptrT_Collar_t swig_types[1456]
#define SWIGTYPE_p_ext__shared_ptrT_ComplexChooserOption_t swig_types[1457]
#define SWIGTYPE_p_ext__shared_ptrT_CompositeConstraint_t swig_types[1458]
#define SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t swig_types[1459]
#define SWIGTYPE_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t swig_types[1460]
#define SWIGTYPE_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_t swig_types[1461]
#define SWIGTYPE_p_ext__shared_ptrT_CompoundOption_t swig_types[1462]
#define SWIGTYPE_p_ext__shared_ptrT_CompoundingRatePricer_t swig_types[1463]
#define SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t swig_types[1464]
#define SWIGTYPE_p_ext__shared_ptrT_ConjugateGradient_t swig_types[1465]
#define SWIGTYPE_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_t swig_types[1466]
#define SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t swig_types[1467]
#define SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t swig_types[1468]
#define SWIGTYPE_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t swig_types[1469]
#define SWIGTYPE_p_ext__shared_ptrT_Constraint_t swig_types[1470]
#define SWIGTYPE_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t swig_types[1471]
#define SWIGTYPE_p_ext__shared_ptrT_ContinuousAveragingAsianOption_t swig_types[1472]
#define SWIGTYPE_p_ext__shared_ptrT_ContinuousFixedLookbackOption_t swig_types[1473]
#define SWIGTYPE_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_t swig_types[1474]
#define SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_t swig_types[1475]
#define SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_t swig_types[1476]
#define SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t swig_types[1477]
#define SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t swig_types[1478]
#define SWIGTYPE_p_ext__shared_ptrT_ConvertibleZeroCouponBond_t swig_types[1479]
#define SWIGTYPE_p_ext__shared_ptrT_Corra_t swig_types[1480]
#define SWIGTYPE_p_ext__shared_ptrT_Coupon_t swig_types[1481]
#define SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t swig_types[1482]
#define SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t swig_types[1483]
#define SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t swig_types[1484]
#define SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t swig_types[1485]
#define SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t swig_types[1486]
#define SWIGTYPE_p_ext__shared_ptrT_DKKLibor_t swig_types[1487]
#define SWIGTYPE_p_ext__shared_ptrT_DailyTenorLibor_t swig_types[1488]
#define SWIGTYPE_p_ext__shared_ptrT_DatedOISRateHelper_t swig_types[1489]
#define SWIGTYPE_p_ext__shared_ptrT_DefaultBoundaryCondition_t swig_types[1490]
#define SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t swig_types[1491]
#define SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t swig_types[1492]
#define SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t swig_types[1493]
#define SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t swig_types[1494]
#define SWIGTYPE_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t swig_types[1495]
#define SWIGTYPE_p_ext__shared_ptrT_Destr_t swig_types[1496]
#define SWIGTYPE_p_ext__shared_ptrT_DifferentialEvolution_t swig_types[1497]
#define SWIGTYPE_p_ext__shared_ptrT_DirichletBC_t swig_types[1498]
#define SWIGTYPE_p_ext__shared_ptrT_DiscountingBondEngine_t swig_types[1499]
#define SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t swig_types[1500]
#define SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t swig_types[1501]
#define SWIGTYPE_p_ext__shared_ptrT_DividendBarrierOption_t swig_types[1502]
#define SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t swig_types[1503]
#define SWIGTYPE_p_ext__shared_ptrT_Dividend_t swig_types[1504]
#define SWIGTYPE_p_ext__shared_ptrT_DoubleBarrierOption_t swig_types[1505]
#define SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t swig_types[1506]
#define SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t swig_types[1507]
#define SWIGTYPE_p_ext__shared_ptrT_EUHICP_t swig_types[1508]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor10M_t swig_types[1509]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor11M_t swig_types[1510]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor1M_t swig_types[1511]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor1Y_t swig_types[1512]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor2M_t swig_types[1513]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor2W_t swig_types[1514]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor3M_t swig_types[1515]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor4M_t swig_types[1516]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor5M_t swig_types[1517]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor6M_t swig_types[1518]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor7M_t swig_types[1519]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor8M_t swig_types[1520]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor9M_t swig_types[1521]
#define SWIGTYPE_p_ext__shared_ptrT_EURLiborSW_t swig_types[1522]
#define SWIGTYPE_p_ext__shared_ptrT_EURLibor_t swig_types[1523]
#define SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t swig_types[1524]
#define SWIGTYPE_p_ext__shared_ptrT_Eonia_t swig_types[1525]
#define SWIGTYPE_p_ext__shared_ptrT_EquityCashFlowPricer_t swig_types[1526]
#define SWIGTYPE_p_ext__shared_ptrT_EquityCashFlow_t swig_types[1527]
#define SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t swig_types[1528]
#define SWIGTYPE_p_ext__shared_ptrT_EquityQuantoCashFlowPricer_t swig_types[1529]
#define SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t swig_types[1530]
#define SWIGTYPE_p_ext__shared_ptrT_Estr_t swig_types[1531]
#define SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIfrFix_t swig_types[1532]
#define SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t swig_types[1533]
#define SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t swig_types[1534]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor10M_t swig_types[1535]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor11M_t swig_types[1536]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor1M_t swig_types[1537]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor1Y_t swig_types[1538]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor2M_t swig_types[1539]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor2W_t swig_types[1540]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_10M_t swig_types[1541]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_11M_t swig_types[1542]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_1M_t swig_types[1543]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_1Y_t swig_types[1544]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_2M_t swig_types[1545]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_2W_t swig_types[1546]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_3M_t swig_types[1547]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_3W_t swig_types[1548]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_4M_t swig_types[1549]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_5M_t swig_types[1550]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_6M_t swig_types[1551]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_7M_t swig_types[1552]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_8M_t swig_types[1553]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_9M_t swig_types[1554]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_SW_t swig_types[1555]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor365_t swig_types[1556]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor3M_t swig_types[1557]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor3W_t swig_types[1558]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor4M_t swig_types[1559]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor5M_t swig_types[1560]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor6M_t swig_types[1561]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor7M_t swig_types[1562]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor8M_t swig_types[1563]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor9M_t swig_types[1564]
#define SWIGTYPE_p_ext__shared_ptrT_EuriborSW_t swig_types[1565]
#define SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIfrFix_t swig_types[1566]
#define SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t swig_types[1567]
#define SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t swig_types[1568]
#define SWIGTYPE_p_ext__shared_ptrT_Euribor_t swig_types[1569]
#define SWIGTYPE_p_ext__shared_ptrT_EuropeanExercise_t swig_types[1570]
#define SWIGTYPE_p_ext__shared_ptrT_EuropeanOption_t swig_types[1571]
#define SWIGTYPE_p_ext__shared_ptrT_EverestOption_t swig_types[1572]
#define SWIGTYPE_p_ext__shared_ptrT_Exercise_t swig_types[1573]
#define SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t swig_types[1574]
#define SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t swig_types[1575]
#define SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t swig_types[1576]
#define SWIGTYPE_p_ext__shared_ptrT_ExponentialJump1dMesher_t swig_types[1577]
#define SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t swig_types[1578]
#define SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t swig_types[1579]
#define SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t swig_types[1580]
#define SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t swig_types[1581]
#define SWIGTYPE_p_ext__shared_ptrT_FFTVarianceGammaEngine_t swig_types[1582]
#define SWIGTYPE_p_ext__shared_ptrT_FRHICP_t swig_types[1583]
#define SWIGTYPE_p_ext__shared_ptrT_FaceValueAccrualClaim_t swig_types[1584]
#define SWIGTYPE_p_ext__shared_ptrT_FaceValueClaim_t swig_types[1585]
#define SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t swig_types[1586]
#define SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t swig_types[1587]
#define SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesAsianEngine_t swig_types[1588]
#define SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t swig_types[1589]
#define SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t swig_types[1590]
#define SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t swig_types[1591]
#define SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t swig_types[1592]
#define SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t swig_types[1593]
#define SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t swig_types[1594]
#define SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t swig_types[1595]
#define SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t swig_types[1596]
#define SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t swig_types[1597]
#define SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t swig_types[1598]
#define SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t swig_types[1599]
#define SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t swig_types[1600]
#define SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t swig_types[1601]
#define SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t swig_types[1602]
#define SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t swig_types[1603]
#define SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t swig_types[1604]
#define SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t swig_types[1605]
#define SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t swig_types[1606]
#define SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t swig_types[1607]
#define SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t swig_types[1608]
#define SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t swig_types[1609]
#define SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t swig_types[1610]
#define SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t swig_types[1611]
#define SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t swig_types[1612]
#define SWIGTYPE_p_ext__shared_ptrT_FdmAmericanStepCondition_t swig_types[1613]
#define SWIGTYPE_p_ext__shared_ptrT_FdmArithmeticAverageCondition_t swig_types[1614]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBackwardSolver_t swig_types[1615]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBatesOp_t swig_types[1616]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBermudanStepCondition_t swig_types[1617]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t swig_types[1618]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesMesher_t swig_types[1619]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t swig_types[1620]
#define SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t swig_types[1621]
#define SWIGTYPE_p_ext__shared_ptrT_FdmCEV1dMesher_t swig_types[1622]
#define SWIGTYPE_p_ext__shared_ptrT_FdmCEVOp_t swig_types[1623]
#define SWIGTYPE_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t swig_types[1624]
#define SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t swig_types[1625]
#define SWIGTYPE_p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t swig_types[1626]
#define SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t swig_types[1627]
#define SWIGTYPE_p_ext__shared_ptrT_FdmDupire1dOp_t swig_types[1628]
#define SWIGTYPE_p_ext__shared_ptrT_FdmG2Op_t swig_types[1629]
#define SWIGTYPE_p_ext__shared_ptrT_FdmG2Solver_t swig_types[1630]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonFwdOp_t swig_types[1631]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteOp_t swig_types[1632]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t swig_types[1633]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t swig_types[1634]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonOp_t swig_types[1635]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t swig_types[1636]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t swig_types[1637]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteOp_t swig_types[1638]
#define SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteSolver_t swig_types[1639]
#define SWIGTYPE_p_ext__shared_ptrT_FdmIndicesOnBoundary_t swig_types[1640]
#define SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t swig_types[1641]
#define SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t swig_types[1642]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t swig_types[1643]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t swig_types[1644]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t swig_types[1645]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLinearOp_t swig_types[1646]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLocalVolFwdOp_t swig_types[1647]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLogBasketInnerValue_t swig_types[1648]
#define SWIGTYPE_p_ext__shared_ptrT_FdmLogInnerValue_t swig_types[1649]
#define SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t swig_types[1650]
#define SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t swig_types[1651]
#define SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t swig_types[1652]
#define SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t swig_types[1653]
#define SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t swig_types[1654]
#define SWIGTYPE_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t swig_types[1655]
#define SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t swig_types[1656]
#define SWIGTYPE_p_ext__shared_ptrT_FdmSabrOp_t swig_types[1657]
#define SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t swig_types[1658]
#define SWIGTYPE_p_ext__shared_ptrT_FdmSimpleStorageCondition_t swig_types[1659]
#define SWIGTYPE_p_ext__shared_ptrT_FdmSimpleSwingCondition_t swig_types[1660]
#define SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t swig_types[1661]
#define SWIGTYPE_p_ext__shared_ptrT_FdmSquareRootFwdOp_t swig_types[1662]
#define SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t swig_types[1663]
#define SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionProxy_t swig_types[1664]
#define SWIGTYPE_p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t swig_types[1665]
#define SWIGTYPE_p_ext__shared_ptrT_FdmZabrOp_t swig_types[1666]
#define SWIGTYPE_p_ext__shared_ptrT_FdmZeroInnerValue_t swig_types[1667]
#define SWIGTYPE_p_ext__shared_ptrT_FedFunds_t swig_types[1668]
#define SWIGTYPE_p_ext__shared_ptrT_FirstDerivativeOp_t swig_types[1669]
#define SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t swig_types[1670]
#define SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t swig_types[1671]
#define SWIGTYPE_p_ext__shared_ptrT_FixedDividend_t swig_types[1672]
#define SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t swig_types[1673]
#define SWIGTYPE_p_ext__shared_ptrT_FixedRateBondForward_t swig_types[1674]
#define SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t swig_types[1675]
#define SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t swig_types[1676]
#define SWIGTYPE_p_ext__shared_ptrT_FixedRateCoupon_t swig_types[1677]
#define SWIGTYPE_p_ext__shared_ptrT_FlatForward_t swig_types[1678]
#define SWIGTYPE_p_ext__shared_ptrT_FlatHazardRate_t swig_types[1679]
#define SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t swig_types[1680]
#define SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t swig_types[1681]
#define SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t swig_types[1682]
#define SWIGTYPE_p_ext__shared_ptrT_FloatingRateBond_t swig_types[1683]
#define SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t swig_types[1684]
#define SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t swig_types[1685]
#define SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t swig_types[1686]
#define SWIGTYPE_p_ext__shared_ptrT_Floor_t swig_types[1687]
#define SWIGTYPE_p_ext__shared_ptrT_ForwardEuropeanEngine_t swig_types[1688]
#define SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t swig_types[1689]
#define SWIGTYPE_p_ext__shared_ptrT_ForwardSpreadedTermStructure_t swig_types[1690]
#define SWIGTYPE_p_ext__shared_ptrT_ForwardVanillaOption_t swig_types[1691]
#define SWIGTYPE_p_ext__shared_ptrT_Forward_t swig_types[1692]
#define SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t swig_types[1693]
#define SWIGTYPE_p_ext__shared_ptrT_FractionalDividend_t swig_types[1694]
#define SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t swig_types[1695]
#define SWIGTYPE_p_ext__shared_ptrT_FxSwapRateHelper_t swig_types[1696]
#define SWIGTYPE_p_ext__shared_ptrT_G2ForwardProcess_t swig_types[1697]
#define SWIGTYPE_p_ext__shared_ptrT_G2Process_t swig_types[1698]
#define SWIGTYPE_p_ext__shared_ptrT_G2SwaptionEngine_t swig_types[1699]
#define SWIGTYPE_p_ext__shared_ptrT_G2_t swig_types[1700]
#define SWIGTYPE_p_ext__shared_ptrT_GBPLiborON_t swig_types[1701]
#define SWIGTYPE_p_ext__shared_ptrT_GBPLibor_t swig_types[1702]
#define SWIGTYPE_p_ext__shared_ptrT_GBSMRNDCalculator_t swig_types[1703]
#define SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t swig_types[1704]
#define SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t swig_types[1705]
#define SWIGTYPE_p_ext__shared_ptrT_GMRES_t swig_types[1706]
#define SWIGTYPE_p_ext__shared_ptrT_GapPayoff_t swig_types[1707]
#define SWIGTYPE_p_ext__shared_ptrT_GarmanKohlagenProcess_t swig_types[1708]
#define SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t swig_types[1709]
#define SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t swig_types[1710]
#define SWIGTYPE_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t swig_types[1711]
#define SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t swig_types[1712]
#define SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t swig_types[1713]
#define SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t swig_types[1714]
#define SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t swig_types[1715]
#define SWIGTYPE_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t swig_types[1716]
#define SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t swig_types[1717]
#define SWIGTYPE_p_ext__shared_ptrT_GeometricBrownianMotionProcess_t swig_types[1718]
#define SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t swig_types[1719]
#define SWIGTYPE_p_ext__shared_ptrT_Glued1dMesher_t swig_types[1720]
#define SWIGTYPE_p_ext__shared_ptrT_GridModelLocalVolSurface_t swig_types[1721]
#define SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t swig_types[1722]
#define SWIGTYPE_p_ext__shared_ptrT_Gsr_t swig_types[1723]
#define SWIGTYPE_p_ext__shared_ptrT_HestonBlackVolSurface_t swig_types[1724]
#define SWIGTYPE_p_ext__shared_ptrT_HestonModelHelper_t swig_types[1725]
#define SWIGTYPE_p_ext__shared_ptrT_HestonModel_t swig_types[1726]
#define SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t swig_types[1727]
#define SWIGTYPE_p_ext__shared_ptrT_HestonRNDCalculator_t swig_types[1728]
#define SWIGTYPE_p_ext__shared_ptrT_HestonSLVProcess_t swig_types[1729]
#define SWIGTYPE_p_ext__shared_ptrT_HimalayaOption_t swig_types[1730]
#define SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t swig_types[1731]
#define SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t swig_types[1732]
#define SWIGTYPE_p_ext__shared_ptrT_HullWhite_t swig_types[1733]
#define SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t swig_types[1734]
#define SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t swig_types[1735]
#define SWIGTYPE_p_ext__shared_ptrT_IborCoupon_t swig_types[1736]
#define SWIGTYPE_p_ext__shared_ptrT_IborIborBasisSwapRateHelper_t swig_types[1737]
#define SWIGTYPE_p_ext__shared_ptrT_IborIndex_t swig_types[1738]
#define SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t swig_types[1739]
#define SWIGTYPE_p_ext__shared_ptrT_ImpliedTermStructure_t swig_types[1740]
#define SWIGTYPE_p_ext__shared_ptrT_Index_t swig_types[1741]
#define SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t swig_types[1742]
#define SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t swig_types[1743]
#define SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t swig_types[1744]
#define SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t swig_types[1745]
#define SWIGTYPE_p_ext__shared_ptrT_Instrument_t swig_types[1746]
#define SWIGTYPE_p_ext__shared_ptrT_IntegralCdsEngine_t swig_types[1747]
#define SWIGTYPE_p_ext__shared_ptrT_IntegralEngine_t swig_types[1748]
#define SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t swig_types[1749]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t swig_types[1750]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t swig_types[1751]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t swig_types[1752]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t swig_types[1753]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t swig_types[1754]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t swig_types[1755]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t swig_types[1756]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t swig_types[1757]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t swig_types[1758]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t swig_types[1759]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t swig_types[1760]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t swig_types[1761]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t swig_types[1762]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t swig_types[1763]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_t swig_types[1764]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t swig_types[1765]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t swig_types[1766]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t swig_types[1767]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t swig_types[1768]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t swig_types[1769]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t swig_types[1770]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t swig_types[1771]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t swig_types[1772]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t swig_types[1773]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t swig_types[1774]
#define SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t swig_types[1775]
#define SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t swig_types[1776]
#define SWIGTYPE_p_ext__shared_ptrT_JPYLibor_t swig_types[1777]
#define SWIGTYPE_p_ext__shared_ptrT_JamshidianSwaptionEngine_t swig_types[1778]
#define SWIGTYPE_p_ext__shared_ptrT_Jibar_t swig_types[1779]
#define SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t swig_types[1780]
#define SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t swig_types[1781]
#define SWIGTYPE_p_ext__shared_ptrT_JuQuadraticApproximationEngine_t swig_types[1782]
#define SWIGTYPE_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t swig_types[1783]
#define SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t swig_types[1784]
#define SWIGTYPE_p_ext__shared_ptrT_KerkhofSeasonality_t swig_types[1785]
#define SWIGTYPE_p_ext__shared_ptrT_KirkEngine_t swig_types[1786]
#define SWIGTYPE_p_ext__shared_ptrT_KirkSpreadOptionEngine_t swig_types[1787]
#define SWIGTYPE_p_ext__shared_ptrT_KlugeExtOUProcess_t swig_types[1788]
#define SWIGTYPE_p_ext__shared_ptrT_LastFixingQuote_t swig_types[1789]
#define SWIGTYPE_p_ext__shared_ptrT_LazyObject_t swig_types[1790]
#define SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t swig_types[1791]
#define SWIGTYPE_p_ext__shared_ptrT_Libor_t swig_types[1792]
#define SWIGTYPE_p_ext__shared_ptrT_LinearTsrPricer_t swig_types[1793]
#define SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t swig_types[1794]
#define SWIGTYPE_p_ext__shared_ptrT_LocalVolRNDCalculator_t swig_types[1795]
#define SWIGTYPE_p_ext__shared_ptrT_LocalVolSurface_t swig_types[1796]
#define SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t swig_types[1797]
#define SWIGTYPE_p_ext__shared_ptrT_LogNormalFwdRateIpc_t swig_types[1798]
#define SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t swig_types[1799]
#define SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t swig_types[1800]
#define SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t swig_types[1801]
#define SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t swig_types[1802]
#define SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t swig_types[1803]
#define SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t swig_types[1804]
#define SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t swig_types[1805]
#define SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t swig_types[1806]
#define SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_LowDiscrepancy_t_t swig_types[1807]
#define SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_PseudoRandom_t_t swig_types[1808]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t swig_types[1809]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t swig_types[1810]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t_t swig_types[1811]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t_t swig_types[1812]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t swig_types[1813]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t swig_types[1814]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t swig_types[1815]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t swig_types[1816]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t_t swig_types[1817]
#define SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t_t swig_types[1818]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t swig_types[1819]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t swig_types[1820]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t swig_types[1821]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t swig_types[1822]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t swig_types[1823]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t swig_types[1824]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t swig_types[1825]
#define SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t swig_types[1826]
#define SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t swig_types[1827]
#define SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t swig_types[1828]
#define SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_LowDiscrepancy_t_t swig_types[1829]
#define SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_PseudoRandom_t_t swig_types[1830]
#define SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t_t swig_types[1831]
#define SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_PseudoRandom_t_t swig_types[1832]
#define SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t swig_types[1833]
#define SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t swig_types[1834]
#define SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_LowDiscrepancy_t_t swig_types[1835]
#define SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_PseudoRandom_t_t swig_types[1836]
#define SWIGTYPE_p_ext__shared_ptrT_MTBrownianGeneratorFactory_t swig_types[1837]
#define SWIGTYPE_p_ext__shared_ptrT_MTBrownianGenerator_t swig_types[1838]
#define SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t swig_types[1839]
#define SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t swig_types[1840]
#define SWIGTYPE_p_ext__shared_ptrT_MarketModel_t swig_types[1841]
#define SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t swig_types[1842]
#define SWIGTYPE_p_ext__shared_ptrT_MaxBasketPayoff_t swig_types[1843]
#define SWIGTYPE_p_ext__shared_ptrT_Merton76Process_t swig_types[1844]
#define SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t swig_types[1845]
#define SWIGTYPE_p_ext__shared_ptrT_MidPointCdsEngine_t swig_types[1846]
#define SWIGTYPE_p_ext__shared_ptrT_MinBasketPayoff_t swig_types[1847]
#define SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t swig_types[1848]
#define SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t swig_types[1849]
#define SWIGTYPE_p_ext__shared_ptrT_Mosprime_t swig_types[1850]
#define SWIGTYPE_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_t swig_types[1851]
#define SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t swig_types[1852]
#define SWIGTYPE_p_ext__shared_ptrT_MultiplicativePriceSeasonality_t swig_types[1853]
#define SWIGTYPE_p_ext__shared_ptrT_NZDLibor_t swig_types[1854]
#define SWIGTYPE_p_ext__shared_ptrT_NelsonSiegelFitting_t swig_types[1855]
#define SWIGTYPE_p_ext__shared_ptrT_NeumannBC_t swig_types[1856]
#define SWIGTYPE_p_ext__shared_ptrT_NinePointLinearOp_t swig_types[1857]
#define SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t swig_types[1858]
#define SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t swig_types[1859]
#define SWIGTYPE_p_ext__shared_ptrT_NoConstraint_t swig_types[1860]
#define SWIGTYPE_p_ext__shared_ptrT_NoExceptLocalVolSurface_t swig_types[1861]
#define SWIGTYPE_p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t swig_types[1862]
#define SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t swig_types[1863]
#define SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t swig_types[1864]
#define SWIGTYPE_p_ext__shared_ptrT_NthOrderDerivativeOp_t swig_types[1865]
#define SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t swig_types[1866]
#define SWIGTYPE_p_ext__shared_ptrT_Nzocr_t swig_types[1867]
#define SWIGTYPE_p_ext__shared_ptrT_OISRateHelper_t swig_types[1868]
#define SWIGTYPE_p_ext__shared_ptrT_Observable_t swig_types[1869]
#define SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t swig_types[1870]
#define SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t swig_types[1871]
#define SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t swig_types[1872]
#define SWIGTYPE_p_ext__shared_ptrT_Option_t swig_types[1873]
#define SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t swig_types[1874]
#define SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t swig_types[1875]
#define SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t swig_types[1876]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_t swig_types[1877]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t swig_types[1878]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t swig_types[1879]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t swig_types[1880]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t swig_types[1881]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t swig_types[1882]
#define SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t swig_types[1883]
#define SWIGTYPE_p_ext__shared_ptrT_PartialTimeBarrierOption_t swig_types[1884]
#define SWIGTYPE_p_ext__shared_ptrT_Payoff_t swig_types[1885]
#define SWIGTYPE_p_ext__shared_ptrT_PercentageStrikePayoff_t swig_types[1886]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t swig_types[1887]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t swig_types[1888]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t swig_types[1889]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t swig_types[1890]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t swig_types[1891]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t swig_types[1892]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t swig_types[1893]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t swig_types[1894]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t swig_types[1895]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t swig_types[1896]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t swig_types[1897]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t swig_types[1898]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t swig_types[1899]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t swig_types[1900]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t swig_types[1901]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t swig_types[1902]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t swig_types[1903]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t swig_types[1904]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t swig_types[1905]
#define SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t swig_types[1906]
#define SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t swig_types[1907]
#define SWIGTYPE_p_ext__shared_ptrT_PositiveConstraint_t swig_types[1908]
#define SWIGTYPE_p_ext__shared_ptrT_Predefined1dMesher_t swig_types[1909]
#define SWIGTYPE_p_ext__shared_ptrT_Pribor_t swig_types[1910]
#define SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t swig_types[1911]
#define SWIGTYPE_p_ext__shared_ptrT_QdFpAmericanEngine_t swig_types[1912]
#define SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t swig_types[1913]
#define SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreScheme_t swig_types[1914]
#define SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreTanhSinhScheme_t swig_types[1915]
#define SWIGTYPE_p_ext__shared_ptrT_QdFpTanhSinhIterationScheme_t swig_types[1916]
#define SWIGTYPE_p_ext__shared_ptrT_QdPlusAmericanEngine_t swig_types[1917]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierEngine_t swig_types[1918]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierOption_t swig_types[1919]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t swig_types[1920]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoEuropeanEngine_t swig_types[1921]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t swig_types[1922]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoForwardVanillaOption_t swig_types[1923]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoTermStructure_t swig_types[1924]
#define SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t swig_types[1925]
#define SWIGTYPE_p_ext__shared_ptrT_Quote_t swig_types[1926]
#define SWIGTYPE_p_ext__shared_ptrT_RateHelper_t swig_types[1927]
#define SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t swig_types[1928]
#define SWIGTYPE_p_ext__shared_ptrT_Redemption_t swig_types[1929]
#define SWIGTYPE_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t swig_types[1930]
#define SWIGTYPE_p_ext__shared_ptrT_RiskyBondEngine_t swig_types[1931]
#define SWIGTYPE_p_ext__shared_ptrT_Robor_t swig_types[1932]
#define SWIGTYPE_p_ext__shared_ptrT_SEKLibor_t swig_types[1933]
#define SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t swig_types[1934]
#define SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t swig_types[1935]
#define SWIGTYPE_p_ext__shared_ptrT_Seasonality_t swig_types[1936]
#define SWIGTYPE_p_ext__shared_ptrT_SecondDerivativeOp_t swig_types[1937]
#define SWIGTYPE_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t swig_types[1938]
#define SWIGTYPE_p_ext__shared_ptrT_Shibor_t swig_types[1939]
#define SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t swig_types[1940]
#define SWIGTYPE_p_ext__shared_ptrT_SimpleCashFlow_t swig_types[1941]
#define SWIGTYPE_p_ext__shared_ptrT_SimpleChooserOption_t swig_types[1942]
#define SWIGTYPE_p_ext__shared_ptrT_SimplePolynomialFitting_t swig_types[1943]
#define SWIGTYPE_p_ext__shared_ptrT_SimpleQuote_t swig_types[1944]
#define SWIGTYPE_p_ext__shared_ptrT_Simplex_t swig_types[1945]
#define SWIGTYPE_p_ext__shared_ptrT_SmileSection_t swig_types[1946]
#define SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t swig_types[1947]
#define SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGenerator_t swig_types[1948]
#define SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t swig_types[1949]
#define SWIGTYPE_p_ext__shared_ptrT_Sofr_t swig_types[1950]
#define SWIGTYPE_p_ext__shared_ptrT_SoftCallability_t swig_types[1951]
#define SWIGTYPE_p_ext__shared_ptrT_Sonia_t swig_types[1952]
#define SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t swig_types[1953]
#define SWIGTYPE_p_ext__shared_ptrT_SpreadBasketPayoff_t swig_types[1954]
#define SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t swig_types[1955]
#define SWIGTYPE_p_ext__shared_ptrT_SpreadFittingMethod_t swig_types[1956]
#define SWIGTYPE_p_ext__shared_ptrT_SpreadOption_t swig_types[1957]
#define SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t swig_types[1958]
#define SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t swig_types[1959]
#define SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t swig_types[1960]
#define SWIGTYPE_p_ext__shared_ptrT_SteepestDescent_t swig_types[1961]
#define SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t swig_types[1962]
#define SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t swig_types[1963]
#define SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t swig_types[1964]
#define SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t swig_types[1965]
#define SWIGTYPE_p_ext__shared_ptrT_Stock_t swig_types[1966]
#define SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t swig_types[1967]
#define SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletAdapter_t swig_types[1968]
#define SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t swig_types[1969]
#define SWIGTYPE_p_ext__shared_ptrT_StrippedOptionlet_t swig_types[1970]
#define SWIGTYPE_p_ext__shared_ptrT_StulzEngine_t swig_types[1971]
#define SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t swig_types[1972]
#define SWIGTYPE_p_ext__shared_ptrT_SubPeriodsPricer_t swig_types[1973]
#define SWIGTYPE_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_t swig_types[1974]
#define SWIGTYPE_p_ext__shared_ptrT_SuperSharePayoff_t swig_types[1975]
#define SWIGTYPE_p_ext__shared_ptrT_SvenssonFitting_t swig_types[1976]
#define SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t swig_types[1977]
#define SWIGTYPE_p_ext__shared_ptrT_SviSmileSection_t swig_types[1978]
#define SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t swig_types[1979]
#define SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t swig_types[1980]
#define SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t swig_types[1981]
#define SWIGTYPE_p_ext__shared_ptrT_Swap_t swig_types[1982]
#define SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t swig_types[1983]
#define SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityCube_t swig_types[1984]
#define SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t swig_types[1985]
#define SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t swig_types[1986]
#define SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t swig_types[1987]
#define SWIGTYPE_p_ext__shared_ptrT_Swaption_t swig_types[1988]
#define SWIGTYPE_p_ext__shared_ptrT_Swestr_t swig_types[1989]
#define SWIGTYPE_p_ext__shared_ptrT_SwingExercise_t swig_types[1990]
#define SWIGTYPE_p_ext__shared_ptrT_THBFIX_t swig_types[1991]
#define SWIGTYPE_p_ext__shared_ptrT_TRLibor_t swig_types[1992]
#define SWIGTYPE_p_ext__shared_ptrT_TermStructureConsistentModel_t swig_types[1993]
#define SWIGTYPE_p_ext__shared_ptrT_TermStructure_t swig_types[1994]
#define SWIGTYPE_p_ext__shared_ptrT_Tibor_t swig_types[1995]
#define SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t swig_types[1996]
#define SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t swig_types[1997]
#define SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t swig_types[1998]
#define SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t swig_types[1999]
#define SWIGTYPE_p_ext__shared_ptrT_TurnbullWakemanAsianEngine_t swig_types[2000]
#define SWIGTYPE_p_ext__shared_ptrT_TypePayoff_t swig_types[2001]
#define SWIGTYPE_p_ext__shared_ptrT_UKHICP_t swig_types[2002]
#define SWIGTYPE_p_ext__shared_ptrT_UKRPI_t swig_types[2003]
#define SWIGTYPE_p_ext__shared_ptrT_USCPI_t swig_types[2004]
#define SWIGTYPE_p_ext__shared_ptrT_USDLiborON_t swig_types[2005]
#define SWIGTYPE_p_ext__shared_ptrT_USDLibor_t swig_types[2006]
#define SWIGTYPE_p_ext__shared_ptrT_UltimateForwardTermStructure_t swig_types[2007]
#define SWIGTYPE_p_ext__shared_ptrT_Uniform1dMesher_t swig_types[2008]
#define SWIGTYPE_p_ext__shared_ptrT_UnitDisplacedBlackYoYInflationCouponPricer_t swig_types[2009]
#define SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t swig_types[2010]
#define SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t swig_types[2011]
#define SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t swig_types[2012]
#define SWIGTYPE_p_ext__shared_ptrT_VanillaForwardPayoff_t swig_types[2013]
#define SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t swig_types[2014]
#define SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t swig_types[2015]
#define SWIGTYPE_p_ext__shared_ptrT_VanillaSwingOption_t swig_types[2016]
#define SWIGTYPE_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t swig_types[2017]
#define SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t swig_types[2018]
#define SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t swig_types[2019]
#define SWIGTYPE_p_ext__shared_ptrT_VarianceGammaEngine_t swig_types[2020]
#define SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t swig_types[2021]
#define SWIGTYPE_p_ext__shared_ptrT_Vasicek_t swig_types[2022]
#define SWIGTYPE_p_ext__shared_ptrT_VolatilityTermStructure_t swig_types[2023]
#define SWIGTYPE_p_ext__shared_ptrT_Wibor_t swig_types[2024]
#define SWIGTYPE_p_ext__shared_ptrT_YYEUHICPXT_t swig_types[2025]
#define SWIGTYPE_p_ext__shared_ptrT_YYEUHICP_t swig_types[2026]
#define SWIGTYPE_p_ext__shared_ptrT_YYEUHICPr_t swig_types[2027]
#define SWIGTYPE_p_ext__shared_ptrT_YYFRHICP_t swig_types[2028]
#define SWIGTYPE_p_ext__shared_ptrT_YYFRHICPr_t swig_types[2029]
#define SWIGTYPE_p_ext__shared_ptrT_YYUKRPI_t swig_types[2030]
#define SWIGTYPE_p_ext__shared_ptrT_YYUKRPIr_t swig_types[2031]
#define SWIGTYPE_p_ext__shared_ptrT_YYUSCPI_t swig_types[2032]
#define SWIGTYPE_p_ext__shared_ptrT_YYUSCPIr_t swig_types[2033]
#define SWIGTYPE_p_ext__shared_ptrT_YYZACPI_t swig_types[2034]
#define SWIGTYPE_p_ext__shared_ptrT_YYZACPIr_t swig_types[2035]
#define SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t swig_types[2036]
#define SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t swig_types[2037]
#define SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t swig_types[2038]
#define SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t swig_types[2039]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t swig_types[2040]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t swig_types[2041]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t swig_types[2042]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t swig_types[2043]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationCap_t swig_types[2044]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationCollar_t swig_types[2045]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationCouponPricer_t swig_types[2046]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t swig_types[2047]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationFloor_t swig_types[2048]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t swig_types[2049]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t swig_types[2050]
#define SWIGTYPE_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t swig_types[2051]
#define SWIGTYPE_p_ext__shared_ptrT_YoYOptionletHelper_t swig_types[2052]
#define SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t swig_types[2053]
#define SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t swig_types[2054]
#define SWIGTYPE_p_ext__shared_ptrT_ZACPI_t swig_types[2055]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t swig_types[2056]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t swig_types[2057]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t swig_types[2058]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t swig_types[2059]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t swig_types[2060]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t swig_types[2061]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t swig_types[2062]
#define SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t swig_types[2063]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroCouponBond_t swig_types[2064]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t swig_types[2065]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t swig_types[2066]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t swig_types[2067]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t swig_types[2068]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t swig_types[2069]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t swig_types[2070]
#define SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t swig_types[2071]
#define SWIGTYPE_p_ext__shared_ptrT_Zibor_t swig_types[2072]
#define SWIGTYPE_p_ext__tupleT_double_double_bool_t swig_types[2073]
#define SWIGTYPE_p_ext__tupleT_double_double_double_t swig_types[2074]
#define SWIGTYPE_p_first_type swig_types[2075]
#define SWIGTYPE_p_int swig_types[2076]
#define SWIGTYPE_p_key_type swig_types[2077]
#define SWIGTYPE_p_long swig_types[2078]
#define SWIGTYPE_p_mapped_type swig_types[2079]
#define SWIGTYPE_p_p_PyObject swig_types[2080]
#define SWIGTYPE_p_sample_type swig_types[2081]
#define SWIGTYPE_p_second_type swig_types[2082]
#define SWIGTYPE_p_size_t swig_types[2083]
#define SWIGTYPE_p_size_type swig_types[2084]
#define SWIGTYPE_p_std__allocatorT_Calendar_t swig_types[2085]
#define SWIGTYPE_p_std__allocatorT_Date_t swig_types[2086]
#define SWIGTYPE_p_std__allocatorT_HandleT_Quote_t_t swig_types[2087]
#define SWIGTYPE_p_std__allocatorT_InterestRate_t swig_types[2088]
#define SWIGTYPE_p_std__allocatorT_IntervalPrice_t swig_types[2089]
#define SWIGTYPE_p_std__allocatorT_Period_t swig_types[2090]
#define SWIGTYPE_p_std__allocatorT_RelinkableHandleT_Quote_t_t swig_types[2091]
#define SWIGTYPE_p_std__allocatorT_bool_t swig_types[2092]
#define SWIGTYPE_p_std__allocatorT_double_t swig_types[2093]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t swig_types[2094]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t swig_types[2095]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t swig_types[2096]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t swig_types[2097]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t swig_types[2098]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t swig_types[2099]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Callability_t_t swig_types[2100]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t swig_types[2101]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t swig_types[2102]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t swig_types[2103]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Dividend_t_t swig_types[2104]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t swig_types[2105]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t swig_types[2106]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Instrument_t_t swig_types[2107]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Quote_t_t swig_types[2108]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t swig_types[2109]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t swig_types[2110]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t swig_types[2111]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t swig_types[2112]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t swig_types[2113]
#define SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t swig_types[2114]
#define SWIGTYPE_p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t swig_types[2115]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[2116]
#define SWIGTYPE_p_std__allocatorT_std__pairT_Date_double_t_t swig_types[2117]
#define SWIGTYPE_p_std__allocatorT_std__pairT_double_const_Date_t_t swig_types[2118]
#define SWIGTYPE_p_std__allocatorT_std__pairT_double_double_t_t swig_types[2119]
#define SWIGTYPE_p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t swig_types[2120]
#define SWIGTYPE_p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t swig_types[2121]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[2122]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t swig_types[2123]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t swig_types[2124]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[2125]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t swig_types[2126]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t swig_types[2127]
#define SWIGTYPE_p_std__allocatorT_unsigned_int_t swig_types[2128]
#define SWIGTYPE_p_std__invalid_argument swig_types[2129]
#define SWIGTYPE_p_std__lessT_double_t swig_types[2130]
#define SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t swig_types[2131]
#define SWIGTYPE_p_std__pairT_Date_Date_t swig_types[2132]
#define SWIGTYPE_p_std__pairT_Date_double_t swig_types[2133]
#define SWIGTYPE_p_std__pairT_double_double_t swig_types[2134]
#define SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t swig_types[2135]
#define SWIGTYPE_p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[2136]
#define SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[2137]
#define SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t swig_types[2138]
#define SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t swig_types[2139]
#define SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t swig_types[2140]
#define SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t swig_types[2141]
#define SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t swig_types[2142]
#define SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t swig_types[2143]
#define SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t swig_types[2144]
#define SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t swig_types[2145]
#define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[2146]
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[2147]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t swig_types[2148]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t swig_types[2149]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t swig_types[2150]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t swig_types[2151]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t swig_types[2152]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t swig_types[2153]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t swig_types[2154]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t swig_types[2155]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t swig_types[2156]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t swig_types[2157]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t swig_types[2158]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t swig_types[2159]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t swig_types[2160]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t swig_types[2161]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t swig_types[2162]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t swig_types[2163]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t swig_types[2164]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t swig_types[2165]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t swig_types[2166]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t swig_types[2167]
#define SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t swig_types[2168]
#define SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t swig_types[2169]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[2170]
#define SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t swig_types[2171]
#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[2172]
#define SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t swig_types[2173]
#define SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t swig_types[2174]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[2175]
#define SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t swig_types[2176]
#define SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t swig_types[2177]
#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[2178]
#define SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t swig_types[2179]
#define SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t swig_types[2180]
#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[2181]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[2182]
#define SWIGTYPE_p_unsigned_int swig_types[2183]
#define SWIGTYPE_p_unsigned_long swig_types[2184]
#define SWIGTYPE_p_value_type swig_types[2185]
static swig_type_info *swig_types[2187];
static swig_module_info swig_module = {swig_types, 2186, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

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

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

#else
#  define SWIG_init    init_QuantLib

#endif
#define SWIG_name    "_QuantLib"

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

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

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

#endif


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


#include <stdexcept>


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

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

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

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


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


#include <ql/version.hpp>
const int    __hexversion__ = QL_HEX_VERSION;
const char* __version__    = QL_VERSION;


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


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


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


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


#include <typeinfo>
#include <stdexcept>


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


#include <string>


#include <stddef.h>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICEOBJECT PyObject
#else
# define SWIGPY_SLICEOBJECT PySliceObject
#endif


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

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

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

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

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

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

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

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

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

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

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

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

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


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


#include <float.h>


#include <math.h>


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


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


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


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


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


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


  #define SWIG_From_long   PyInt_FromLong 


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


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


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


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


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


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


#include <algorithm>


#include <vector>


#include <utility>


#include <map>


#include <algorithm>


#ifdef barrier
#undef barrier
#endif


#include <ql/quantlib.hpp>

#if QL_HEX_VERSION < 0x01290000
    #error using an old version of QuantLib, please update
#endif

#if defined (SWIGJAVA) || defined (SWIGCSHARP) 
  #ifndef QL_ENABLE_THREAD_SAFE_OBSERVER_PATTERN
    #ifdef BOOST_MSVC
      #pragma message(\
          "Quantlib has not been compiled with the thread-safe "           \
          "observer pattern being enabled. This can lead to spurious "     \
          "crashes or pure virtual function calls within the JVM or .NET "  \
          "ecosystem due to the async garbage collector. Please consider " \
          "enabling QL_ENABLE_THREAD_SAFE_OBSERVER_PATTERN "               \
          "in ql/userconfig.hpp.")
    #else
      #warning \
Quantlib has not been compiled with the thread-safe \
observer pattern being enabled. This can lead to spurious \
crashes or pure virtual function calls within the JVM or .NET \
ecosystem due to the async garbage collector. Please consider \
passing --enable-thread-safe-observer-pattern when using the \
GNU autoconf configure script.
    #endif
  #endif
#endif


// add here SWIG version check

#if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
// disable Swig-dependent warnings

// 'identifier1' has C-linkage specified,
// but returns UDT 'identifier2' which is incompatible with C
#pragma warning(disable: 4190)

// 'int' : forcing value to bool 'true' or 'false' (performance warning)
#pragma warning(disable: 4800)

// debug info too long etc etc
#pragma warning(disable: 4786)
#endif


// we do not want to see the deprecated warnings here
QL_DEPRECATED_DISABLE_WARNING


    namespace QuantLib { namespace ext {} }
    namespace ext = QuantLib::ext;


// This is necessary to avoid compile failures on 
// GCC 4
// see http://svn.boost.org/trac/boost/ticket/1793

#if defined(NDEBUG)
#define BOOST_DISABLE_ASSERTS 1
#endif

#include <boost/algorithm/string/case_conv.hpp>


// generally useful classes
using QuantLib::Error;
using QuantLib::Handle;
using QuantLib::RelinkableHandle;


using QuantLib::Integer;
using QuantLib::BigInteger;
using QuantLib::Natural;
using QuantLib::BigNatural;
using QuantLib::Real;
using QuantLib::Decimal;
using QuantLib::Time;
using QuantLib::Rate;
using QuantLib::Spread;
using QuantLib::DiscountFactor;
using QuantLib::Volatility;
using QuantLib::Probability;
using QuantLib::Size;


#ifndef QL_HIGH_RESOLUTION_DATE
    // They are not defined in the library, so we define them here
    namespace QuantLib {
        typedef int Hour;
        typedef int Minute;
        typedef int Second;
        typedef int Millisecond;
        typedef int Microsecond;
    }
#endif

using QuantLib::Day;
using QuantLib::Year;
using QuantLib::Hour;
using QuantLib::Minute;
using QuantLib::Second;
using QuantLib::Millisecond;
using QuantLib::Microsecond;


using QuantLib::Weekday;
using QuantLib::Sunday;
using QuantLib::Monday;
using QuantLib::Tuesday;
using QuantLib::Wednesday;
using QuantLib::Thursday;
using QuantLib::Friday;
using QuantLib::Saturday;


using QuantLib::Month;
using QuantLib::January;
using QuantLib::February;
using QuantLib::March;
using QuantLib::April;
using QuantLib::May;
using QuantLib::June;
using QuantLib::July;
using QuantLib::August;
using QuantLib::September;
using QuantLib::October;
using QuantLib::November;
using QuantLib::December;


using QuantLib::TimeUnit;
using QuantLib::Days;
using QuantLib::Weeks;
using QuantLib::Months;
using QuantLib::Years;
using QuantLib::Hours;
using QuantLib::Minutes;
using QuantLib::Seconds;
using QuantLib::Milliseconds;
using QuantLib::Microseconds;


using QuantLib::Frequency;
using QuantLib::NoFrequency;
using QuantLib::Once;
using QuantLib::Annual;
using QuantLib::Semiannual;
using QuantLib::EveryFourthMonth;
using QuantLib::Quarterly;
using QuantLib::Bimonthly;
using QuantLib::Monthly;
using QuantLib::EveryFourthWeek;
using QuantLib::Biweekly;
using QuantLib::Weekly;
using QuantLib::Daily;
using QuantLib::OtherFrequency;


using QuantLib::Period;
using QuantLib::PeriodParser;


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


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    if (!obj)
      return SWIG_TypeError;
    if (alloc)
      *alloc = SWIG_NEWOBJ;
#endif
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#endif
    if (cptr) {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
        if (!*cptr)
          ret = SWIG_TypeError;
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

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

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


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

SWIGINTERN Period *new_Period__SWIG_3(std::string const &str){
            return new Period(PeriodParser::parse(str));
        }
SWIGINTERN std::string Period___str__(Period *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }

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

SWIGINTERN std::string Period___repr__(Period *self){
            std::ostringstream out;
            out << "Period(\"" << QuantLib::io::short_period(*self) << "\")";
            return out.str();
        }
SWIGINTERN Period Period___neg__(Period *self){
            return -(*self);
        }
SWIGINTERN Period Period___add__(Period *self,Period const &p){
            return *self + p;
        }
SWIGINTERN Period Period___sub__(Period *self,Period const &p){
            return *self - p;
        }
SWIGINTERN Period Period___mul__(Period *self,Integer n){
            return *self * n;
        }
SWIGINTERN Period Period___rmul__(Period *self,Integer n){
            return *self * n;
        }
SWIGINTERN bool Period___lt__(Period *self,Period const &other){
            return *self < other;
        }
SWIGINTERN bool Period___gt__(Period *self,Period const &other){
            return other < *self;
        }
SWIGINTERN bool Period___le__(Period *self,Period const &other){
            return !(other < *self);
        }
SWIGINTERN bool Period___ge__(Period *self,Period const &other){
            return !(*self < other);
        }
SWIGINTERN bool Period___eq__(Period *self,Period const &other){
            return *self == other;
        }
SWIGINTERN int Period___cmp__(Period *self,Period const &other){
            return *self < other  ? -1 :
                   *self == other ?  0 :
                                     1;
        }

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

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

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

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

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

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

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

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

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

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

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

}


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

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

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

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


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

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

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      int res = SWIG_ERROR;
      swig_type_info *descriptor = type_info<Type>();
      if (val) {
        Type *p = 0;
        int newmem = 0;
        res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR;
        if (SWIG_IsOK(res)) {
          if (newmem & SWIG_CAST_NEW_MEMORY) {
            res |= SWIG_NEWOBJMASK;
          }
          *val = p;
        }
      } else {
        res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR;
      }
      return res;
    }
  }; 

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

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

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

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

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

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

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

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

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


#include <functional>

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

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

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

}

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

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

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

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

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

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

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

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

  template <class Sequence>
  inline void
  erase(Sequence* seq, const typename Sequence::iterator& position) {
    seq->erase(position);
  }

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

  };

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

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

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

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

  protected:
    out_iterator begin;
    out_iterator end;
  };

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

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


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

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

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

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

}


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

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

  private:
    PyObject* _seq;
    Py_ssize_t _index;
  };

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

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

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

    SwigPySequence_InputIterator()
    {
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  private:
    PyObject* _seq;
    difference_type _index;
  };

  // STL container wrapper around a Python sequence
  template <class T>
  struct SwigPySequence_Cont
  {
    typedef SwigPySequence_Ref<T> reference;
    typedef const SwigPySequence_Ref<T> const_reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;
    typedef size_t size_type;
    typedef const pointer const_pointer;
    typedef SwigPySequence_InputIterator<T, reference> iterator;
    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;

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

    ~SwigPySequence_Cont()
    {
      Py_XDECREF(_seq);
    }

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

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

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

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

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

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

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

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

    bool check() const
    {
      Py_ssize_t s = size();
      for (Py_ssize_t i = 0; i < s; ++i) {
	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
	if (!swig::check<value_type>(item))
	  return false;
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}


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


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

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

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

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

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


  namespace swig {
    template <class T>
    struct traits_reserve<std::vector<T> > {
      static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
        seq.reserve(n);
      }
    };

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


      namespace swig {
	template <>  struct traits<std::vector< Period, std::allocator< Period > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Period" "," "std::allocator< Period >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Period_Sg__iterator(std::vector< Period > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Period_Sg____nonzero__(std::vector< Period > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Period_Sg____bool__(std::vector< Period > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Period >::size_type std_vector_Sl_Period_Sg____len__(std::vector< Period > const *self){
      return self->size();
    }

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


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


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

SWIGINTERN std::vector< Period,std::allocator< Period > > *std_vector_Sl_Period_Sg____getslice__(std::vector< Period > *self,std::vector< Period >::difference_type i,std::vector< Period >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Period_Sg____setslice____SWIG_0(std::vector< Period > *self,std::vector< Period >::difference_type i,std::vector< Period >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Period,std::allocator< Period > >());
    }
SWIGINTERN void std_vector_Sl_Period_Sg____setslice____SWIG_1(std::vector< Period > *self,std::vector< Period >::difference_type i,std::vector< Period >::difference_type j,std::vector< Period,std::allocator< Period > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Period_Sg____delslice__(std::vector< Period > *self,std::vector< Period >::difference_type i,std::vector< Period >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Period_Sg____delitem____SWIG_0(std::vector< Period > *self,std::vector< Period >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Period,std::allocator< Period > > *std_vector_Sl_Period_Sg____getitem____SWIG_0(std::vector< Period > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Period,std::allocator< Period > >::difference_type id = i;
      std::vector< Period,std::allocator< Period > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Period_Sg____setitem____SWIG_0(std::vector< Period > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Period,std::allocator< Period > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Period,std::allocator< Period > >::difference_type id = i;
      std::vector< Period,std::allocator< Period > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Period_Sg____setitem____SWIG_1(std::vector< Period > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Period,std::allocator< Period > >::difference_type id = i;
      std::vector< Period,std::allocator< Period > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Period_Sg____delitem____SWIG_1(std::vector< Period > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Period,std::allocator< Period > >::difference_type id = i;
      std::vector< Period,std::allocator< Period > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Period >::value_type const &std_vector_Sl_Period_Sg____getitem____SWIG_1(std::vector< Period > const *self,std::vector< Period >::difference_type i){
      return *(swig::cgetpos(self, i));
    }

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

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

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

SWIGINTERN void std_vector_Sl_Period_Sg____setitem____SWIG_2(std::vector< Period > *self,std::vector< Period >::difference_type i,std::vector< Period >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Period >::value_type std_vector_Sl_Period_Sg__pop(std::vector< Period > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Period,std::allocator< Period > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Period_Sg__append(std::vector< Period > *self,std::vector< Period >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Period >::iterator std_vector_Sl_Period_Sg__erase__SWIG_0(std::vector< Period > *self,std::vector< Period >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Period >::iterator std_vector_Sl_Period_Sg__erase__SWIG_1(std::vector< Period > *self,std::vector< Period >::iterator first,std::vector< Period >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Period >::iterator std_vector_Sl_Period_Sg__insert__SWIG_0(std::vector< Period > *self,std::vector< Period >::iterator pos,std::vector< Period >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Period_Sg__insert__SWIG_1(std::vector< Period > *self,std::vector< Period >::iterator pos,std::vector< Period >::size_type n,std::vector< Period >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Date;
using QuantLib::DateParser;


    // used in Date(string, string) defined below
    void _replace_format(std::string& s, const std::string& old_format,
                         const std::string& new_format) {
        std::string::size_type i = s.find(old_format);
        if (i != std::string::npos)
            s.replace(i, old_format.length(), new_format);
    }

SWIGINTERN Date *new_Date__SWIG_2(Day d,Month m,Year y,Hour hours,Minute minutes,Second seconds,Millisecond millisec=0,Microsecond microsec=0){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return new Date(d, m, y, hours, minutes, seconds,
                            millisec, microsec);
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Hour Date_hours(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->hours();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Minute Date_minutes(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->minutes();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Second Date_seconds(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->seconds();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Millisecond Date_milliseconds(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->milliseconds();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Microsecond Date_microseconds(Date *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->microseconds();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Time Date_fractionOfDay(Date const *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->fractionOfDay();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }

  #define SWIG_From_double   PyFloat_FromDouble 

SWIGINTERN Time Date_fractionOfSecond(Date const *self){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return self->fractionOfSecond();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Date Date_localDateTime(){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return Date::localDateTime();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
        }
SWIGINTERN Date Date_universalDateTime(){
        #ifdef QL_HIGH_RESOLUTION_DATE
            return Date::universalDateTime();
        #else
            throw std::runtime_error("QuantLib was not compiled "
                                     "with intraday support");
        #endif
         }
SWIGINTERN Date *new_Date__SWIG_6(std::string const &str,std::string fmt){
            // convert our old format into the corresponding Boost one
            _replace_format(fmt, "YYYY", "%Y");
            _replace_format(fmt, "yyyy", "%Y");
            _replace_format(fmt, "YY", "%y");
            _replace_format(fmt, "yy", "%y");
            _replace_format(fmt, "MM", "%m");
            _replace_format(fmt, "mm", "%m");
            _replace_format(fmt, "DD", "%d");
            _replace_format(fmt, "dd", "%d");
            return new Date(DateParser::parseFormatted(str,fmt));
        }
SWIGINTERN Integer Date_weekdayNumber(Date *self){
            return int(self->weekday());
        }
SWIGINTERN std::string Date___str__(Date *self){
            std::ostringstream out;
        #ifdef QL_HIGH_RESOLUTION_DATE
            out << QuantLib::io::iso_datetime(*self);
        #else
            out << *self;
        #endif
            return out.str();
        }
SWIGINTERN std::string Date___repr__(Date *self){
            std::ostringstream out;
            if (*self == Date())
                out << "Date()";
            else
        #ifdef QL_HIGH_RESOLUTION_DATE
                out << "Date(" << self->dayOfMonth() << ","
                    << int(self->month()) << "," << self->year() << ","
                    << self->hours() << "," << self->minutes() << ","
                    << self->seconds() << "," << self->milliseconds() << ","
                    << self->microseconds() << ")";
        #else
                out << "Date(" << self->dayOfMonth() << ","
                    << int(self->month()) << "," << self->year() << ")";
        #endif
            return out.str();
        }
SWIGINTERN std::string Date_ISO(Date *self){
            std::ostringstream out;
            out << QuantLib::io::iso_date(*self);
            return out.str();
        }
SWIGINTERN BigInteger Date_operator_Ss___SWIG_2(Date *self,Date const &other){
            return *self - other;
        }
SWIGINTERN bool Date___eq__(Date *self,Date const &other){
            return *self == other;
        }
SWIGINTERN int Date___cmp__(Date *self,Date const &other){
            if (*self < other)
                return -1;
            else if (*self == other)
                return 0;
            else
                return 1;
        }
SWIGINTERN bool Date___nonzero__(Date *self){
            return (*self != Date());
        }
SWIGINTERN bool Date___bool__(Date *self){
            return (*self != Date());
        }
SWIGINTERN int Date___hash__(Date *self){
            return self->serialNumber();
        }
SWIGINTERN bool Date___lt__(Date *self,Date const &other){
            return *self < other;
        }
SWIGINTERN bool Date___gt__(Date *self,Date const &other){
            return other < *self;
        }
SWIGINTERN bool Date___le__(Date *self,Date const &other){
            return !(other < *self);
        }
SWIGINTERN bool Date___ge__(Date *self,Date const &other){
            return !(*self < other);
        }
SWIGINTERN bool Date___ne__(Date *self,Date const &other){
            return *self != other;
        }
SWIGINTERN Date DateParser_parse(std::string const &str,std::string fmt){
            // convert our old format into the corresponding Boost one
            _replace_format(fmt, "YYYY", "%Y");
            _replace_format(fmt, "yyyy", "%Y");
            _replace_format(fmt, "YY", "%y");
            _replace_format(fmt, "yy", "%y");
            _replace_format(fmt, "MM", "%m");
            _replace_format(fmt, "mm", "%m");
            _replace_format(fmt, "DD", "%d");
            _replace_format(fmt, "dd", "%d");
            return DateParser::parseFormatted(str,fmt);
        }

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


      namespace swig {
	template <>  struct traits<std::vector< Date, std::allocator< Date > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Date" "," "std::allocator< Date >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Date_Sg__iterator(std::vector< Date > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Date_Sg____nonzero__(std::vector< Date > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Date_Sg____bool__(std::vector< Date > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Date >::size_type std_vector_Sl_Date_Sg____len__(std::vector< Date > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Date,std::allocator< Date > > *std_vector_Sl_Date_Sg____getslice__(std::vector< Date > *self,std::vector< Date >::difference_type i,std::vector< Date >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Date_Sg____setslice____SWIG_0(std::vector< Date > *self,std::vector< Date >::difference_type i,std::vector< Date >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Date,std::allocator< Date > >());
    }
SWIGINTERN void std_vector_Sl_Date_Sg____setslice____SWIG_1(std::vector< Date > *self,std::vector< Date >::difference_type i,std::vector< Date >::difference_type j,std::vector< Date,std::allocator< Date > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Date_Sg____delslice__(std::vector< Date > *self,std::vector< Date >::difference_type i,std::vector< Date >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Date_Sg____delitem____SWIG_0(std::vector< Date > *self,std::vector< Date >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Date,std::allocator< Date > > *std_vector_Sl_Date_Sg____getitem____SWIG_0(std::vector< Date > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Date,std::allocator< Date > >::difference_type id = i;
      std::vector< Date,std::allocator< Date > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Date_Sg____setitem____SWIG_0(std::vector< Date > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Date,std::allocator< Date > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Date,std::allocator< Date > >::difference_type id = i;
      std::vector< Date,std::allocator< Date > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Date_Sg____setitem____SWIG_1(std::vector< Date > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Date,std::allocator< Date > >::difference_type id = i;
      std::vector< Date,std::allocator< Date > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Date_Sg____delitem____SWIG_1(std::vector< Date > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Date,std::allocator< Date > >::difference_type id = i;
      std::vector< Date,std::allocator< Date > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Date >::value_type const &std_vector_Sl_Date_Sg____getitem____SWIG_1(std::vector< Date > const *self,std::vector< Date >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Date_Sg____setitem____SWIG_2(std::vector< Date > *self,std::vector< Date >::difference_type i,std::vector< Date >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Date >::value_type std_vector_Sl_Date_Sg__pop(std::vector< Date > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Date,std::allocator< Date > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Date_Sg__append(std::vector< Date > *self,std::vector< Date >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Date >::iterator std_vector_Sl_Date_Sg__erase__SWIG_0(std::vector< Date > *self,std::vector< Date >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Date >::iterator std_vector_Sl_Date_Sg__erase__SWIG_1(std::vector< Date > *self,std::vector< Date >::iterator first,std::vector< Date >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Date >::iterator std_vector_Sl_Date_Sg__insert__SWIG_0(std::vector< Date > *self,std::vector< Date >::iterator pos,std::vector< Date >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Date_Sg__insert__SWIG_1(std::vector< Date > *self,std::vector< Date >::iterator pos,std::vector< Date >::size_type n,std::vector< Date >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::IMM;


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


using QuantLib::ASX;


template <class T, class U>
std::vector<T> to_vector(const std::vector<U>& v) {
    std::vector<T> out(v.size());
    std::copy(v.begin(), v.end(), out.begin());
    return out;
}


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


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

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


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


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


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

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


      namespace swig {
	template <>  struct traits<std::vector< double, std::allocator< double > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "double" "," "std::allocator< double >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
      return self->size();
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice,std::vector< double,std::allocator< double > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< double,std::allocator< double > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }

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


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


      namespace swig {
	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector<bool, std::allocator< bool > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<bool, std::allocator< bool > >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_bool_Sg__iterator(std::vector< bool > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_bool_Sg____nonzero__(std::vector< bool > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_bool_Sg____bool__(std::vector< bool > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< bool >::size_type std_vector_Sl_bool_Sg____len__(std::vector< bool > const *self){
      return self->size();
    }
SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector<bool,std::allocator< bool > >());
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j,std::vector< bool,std::allocator< bool > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getitem____SWIG_0(std::vector< bool > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_0(std::vector< bool > *self,SWIGPY_SLICEOBJECT *slice,std::vector< bool,std::allocator< bool > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_1(std::vector< bool > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_1(std::vector< bool > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg____getitem____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_2(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg__pop(std::vector< bool > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<bool,std::allocator< bool > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_bool_Sg__append(std::vector< bool > *self,std::vector< bool >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator first,std::vector< bool >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__insert__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_bool_Sg__insert__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::size_type n,std::vector< bool >::value_type x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {


















































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

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

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


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





































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

      namespace swig {
	template <>  struct traits<std::vector< std::pair< double,double >, std::allocator< std::pair< double,double > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< double,double >" "," "std::allocator< std::pair< double,double > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__iterator(std::vector< std::pair< double,double > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____nonzero__(std::vector< std::pair< double,double > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____bool__(std::vector< std::pair< double,double > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< double,double > >::size_type std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____len__(std::vector< std::pair< double,double > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getslice__(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i,std::vector< std::pair< double,double > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i,std::vector< std::pair< double,double > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i,std::vector< std::pair< double,double > >::difference_type j,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i,std::vector< std::pair< double,double > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< double,double > >::value_type const &std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< double,double > > const *self,std::vector< std::pair< double,double > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i,std::vector< std::pair< double,double > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< double,double > >::value_type std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__pop(std::vector< std::pair< double,double > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__append(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< double,double > >::iterator std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__erase__SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< double,double > >::iterator std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__erase__SWIG_1(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::iterator first,std::vector< std::pair< double,double > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< double,double > >::iterator std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__insert__SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::iterator pos,std::vector< std::pair< double,double > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__insert__SWIG_1(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::iterator pos,std::vector< std::pair< double,double > >::size_type n,std::vector< std::pair< double,double > >::value_type const &x){ self->insert(pos, n, x); }

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

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

      namespace swig {
	template <>  struct traits<std::vector< std::pair< unsigned int,unsigned int >, std::allocator< std::pair< unsigned int,unsigned int > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< unsigned int,unsigned int >" "," "std::allocator< std::pair< unsigned int,unsigned int > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__iterator(std::vector< std::pair< unsigned int,unsigned int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____nonzero__(std::vector< std::pair< unsigned int,unsigned int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____bool__(std::vector< std::pair< unsigned int,unsigned int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::size_type std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____len__(std::vector< std::pair< unsigned int,unsigned int > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getslice__(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delslice__(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::value_type const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > const *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::value_type std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__pop(std::vector< std::pair< unsigned int,unsigned int > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__append(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::iterator std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::iterator std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator first,std::vector< std::pair< unsigned int,unsigned int > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::iterator std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator pos,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator pos,std::vector< std::pair< unsigned int,unsigned int > >::size_type n,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){ self->insert(pos, n, x); }

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

      namespace swig {
	template <>  struct traits<std::vector< std::pair< Date,double >, std::allocator< std::pair< Date,double > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< Date,double >" "," "std::allocator< std::pair< Date,double > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__iterator(std::vector< std::pair< Date,double > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____nonzero__(std::vector< std::pair< Date,double > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____bool__(std::vector< std::pair< Date,double > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< Date,double > >::size_type std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____len__(std::vector< std::pair< Date,double > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____getslice__(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::difference_type i,std::vector< std::pair< Date,double > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::difference_type i,std::vector< std::pair< Date,double > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::difference_type i,std::vector< std::pair< Date,double > >::difference_type j,std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____delslice__(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::difference_type i,std::vector< std::pair< Date,double > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< Date,double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type id = i;
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< Date,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type id = i;
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< Date,double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type id = i;
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< Date,double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type id = i;
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< Date,double > >::value_type const &std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< Date,double > > const *self,std::vector< std::pair< Date,double > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::difference_type i,std::vector< std::pair< Date,double > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< Date,double > >::value_type std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__pop(std::vector< std::pair< Date,double > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__append(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< Date,double > >::iterator std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__erase__SWIG_0(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< Date,double > >::iterator std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__erase__SWIG_1(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::iterator first,std::vector< std::pair< Date,double > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< Date,double > >::iterator std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__insert__SWIG_0(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::iterator pos,std::vector< std::pair< Date,double > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__insert__SWIG_1(std::vector< std::pair< Date,double > > *self,std::vector< std::pair< Date,double > >::iterator pos,std::vector< std::pair< Date,double > >::size_type n,std::vector< std::pair< Date,double > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Calendar;


using QuantLib::BusinessDayConvention;
using QuantLib::Following;
using QuantLib::ModifiedFollowing;
using QuantLib::Preceding;
using QuantLib::ModifiedPreceding;
using QuantLib::Unadjusted;
using QuantLib::HalfMonthModifiedFollowing;
using QuantLib::Nearest;


using QuantLib::JointCalendarRule;
using QuantLib::JoinHolidays;
using QuantLib::JoinBusinessDays;

SWIGINTERN std::string Calendar___str__(Calendar *self){
            return self->name()+" calendar";
        }
SWIGINTERN bool Calendar___eq__(Calendar *self,Calendar const &other){
            return (*self) == other;
        }
SWIGINTERN bool Calendar___ne__(Calendar *self,Calendar const &other){
            return (*self) != other;
        }

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


      namespace swig {
	template <>  struct traits<std::vector< Calendar, std::allocator< Calendar > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Calendar" "," "std::allocator< Calendar >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Calendar_Sg__iterator(std::vector< Calendar > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Calendar_Sg____nonzero__(std::vector< Calendar > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Calendar_Sg____bool__(std::vector< Calendar > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Calendar >::size_type std_vector_Sl_Calendar_Sg____len__(std::vector< Calendar > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Calendar,std::allocator< Calendar > > *std_vector_Sl_Calendar_Sg____getslice__(std::vector< Calendar > *self,std::vector< Calendar >::difference_type i,std::vector< Calendar >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____setslice____SWIG_0(std::vector< Calendar > *self,std::vector< Calendar >::difference_type i,std::vector< Calendar >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Calendar,std::allocator< Calendar > >());
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____setslice____SWIG_1(std::vector< Calendar > *self,std::vector< Calendar >::difference_type i,std::vector< Calendar >::difference_type j,std::vector< Calendar,std::allocator< Calendar > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____delslice__(std::vector< Calendar > *self,std::vector< Calendar >::difference_type i,std::vector< Calendar >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____delitem____SWIG_0(std::vector< Calendar > *self,std::vector< Calendar >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Calendar,std::allocator< Calendar > > *std_vector_Sl_Calendar_Sg____getitem____SWIG_0(std::vector< Calendar > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Calendar,std::allocator< Calendar > >::difference_type id = i;
      std::vector< Calendar,std::allocator< Calendar > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____setitem____SWIG_0(std::vector< Calendar > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Calendar,std::allocator< Calendar > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Calendar,std::allocator< Calendar > >::difference_type id = i;
      std::vector< Calendar,std::allocator< Calendar > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____setitem____SWIG_1(std::vector< Calendar > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Calendar,std::allocator< Calendar > >::difference_type id = i;
      std::vector< Calendar,std::allocator< Calendar > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____delitem____SWIG_1(std::vector< Calendar > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Calendar,std::allocator< Calendar > >::difference_type id = i;
      std::vector< Calendar,std::allocator< Calendar > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Calendar >::value_type const &std_vector_Sl_Calendar_Sg____getitem____SWIG_1(std::vector< Calendar > const *self,std::vector< Calendar >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg____setitem____SWIG_2(std::vector< Calendar > *self,std::vector< Calendar >::difference_type i,std::vector< Calendar >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Calendar >::value_type std_vector_Sl_Calendar_Sg__pop(std::vector< Calendar > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Calendar,std::allocator< Calendar > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Calendar_Sg__append(std::vector< Calendar > *self,std::vector< Calendar >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Calendar >::iterator std_vector_Sl_Calendar_Sg__erase__SWIG_0(std::vector< Calendar > *self,std::vector< Calendar >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Calendar >::iterator std_vector_Sl_Calendar_Sg__erase__SWIG_1(std::vector< Calendar > *self,std::vector< Calendar >::iterator first,std::vector< Calendar >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Calendar >::iterator std_vector_Sl_Calendar_Sg__insert__SWIG_0(std::vector< Calendar > *self,std::vector< Calendar >::iterator pos,std::vector< Calendar >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Calendar_Sg__insert__SWIG_1(std::vector< Calendar > *self,std::vector< Calendar >::iterator pos,std::vector< Calendar >::size_type n,std::vector< Calendar >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Null;
typedef int intOrNull;
typedef double doubleOrNull;


int nullInt() { return Null<int>(); }
double nullDouble() { return Null<double>(); }


using QuantLib::DayCounter;

SWIGINTERN std::string DayCounter___str__(DayCounter *self){
            return self->name()+" day counter";
        }
SWIGINTERN bool DayCounter___eq__(DayCounter *self,DayCounter const &other){
            return (*self) == other;
        }
SWIGINTERN bool DayCounter___ne__(DayCounter *self,DayCounter const &other){
            return (*self) != other;
        }

using QuantLib::yearFractionToDate;


using QuantLib::Rounding;
using QuantLib::UpRounding;
using QuantLib::DownRounding;
using QuantLib::ClosestRounding;
using QuantLib::CeilingTruncation;
using QuantLib::FloorTruncation;


using QuantLib::Currency;
using QuantLib::Money;

SWIGINTERN std::string Currency___str__(Currency *self){
            return self->name();
        }
SWIGINTERN bool Currency___eq__(Currency *self,Currency const &other){
            return (*self) == other;
        }
SWIGINTERN bool Currency___ne__(Currency *self,Currency const &other){
            return (*self) != other;
        }
SWIGINTERN Money Currency_operator_Sm_(Currency *self,Decimal x){
            return *self*x;
        }
SWIGINTERN Money Currency___rmul__(Currency *self,Decimal x){
            return *self*x;
        }
SWIGINTERN bool Currency___nonzero__(Currency *self){
            return !self->empty();
        }
SWIGINTERN bool Currency___bool__(Currency *self){
            return !self->empty();
        }

using QuantLib::Compounding;
using QuantLib::Simple;
using QuantLib::Compounded;
using QuantLib::Continuous;
using QuantLib::SimpleThenCompounded;
using QuantLib::CompoundedThenSimple;


using QuantLib::InterestRate;

SWIGINTERN std::string InterestRate___str__(InterestRate *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }

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


      namespace swig {
	template <>  struct traits<std::vector< InterestRate, std::allocator< InterestRate > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "InterestRate" "," "std::allocator< InterestRate >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_InterestRate_Sg__iterator(std::vector< InterestRate > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_InterestRate_Sg____nonzero__(std::vector< InterestRate > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_InterestRate_Sg____bool__(std::vector< InterestRate > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< InterestRate >::size_type std_vector_Sl_InterestRate_Sg____len__(std::vector< InterestRate > const *self){
      return self->size();
    }
SWIGINTERN std::vector< InterestRate,std::allocator< InterestRate > > *std_vector_Sl_InterestRate_Sg____getslice__(std::vector< InterestRate > *self,std::vector< InterestRate >::difference_type i,std::vector< InterestRate >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____setslice____SWIG_0(std::vector< InterestRate > *self,std::vector< InterestRate >::difference_type i,std::vector< InterestRate >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< InterestRate,std::allocator< InterestRate > >());
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____setslice____SWIG_1(std::vector< InterestRate > *self,std::vector< InterestRate >::difference_type i,std::vector< InterestRate >::difference_type j,std::vector< InterestRate,std::allocator< InterestRate > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____delslice__(std::vector< InterestRate > *self,std::vector< InterestRate >::difference_type i,std::vector< InterestRate >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____delitem____SWIG_0(std::vector< InterestRate > *self,std::vector< InterestRate >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< InterestRate,std::allocator< InterestRate > > *std_vector_Sl_InterestRate_Sg____getitem____SWIG_0(std::vector< InterestRate > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type id = i;
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____setitem____SWIG_0(std::vector< InterestRate > *self,SWIGPY_SLICEOBJECT *slice,std::vector< InterestRate,std::allocator< InterestRate > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type id = i;
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____setitem____SWIG_1(std::vector< InterestRate > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type id = i;
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____delitem____SWIG_1(std::vector< InterestRate > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type id = i;
      std::vector< InterestRate,std::allocator< InterestRate > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< InterestRate >::value_type const &std_vector_Sl_InterestRate_Sg____getitem____SWIG_1(std::vector< InterestRate > const *self,std::vector< InterestRate >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg____setitem____SWIG_2(std::vector< InterestRate > *self,std::vector< InterestRate >::difference_type i,std::vector< InterestRate >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< InterestRate >::value_type std_vector_Sl_InterestRate_Sg__pop(std::vector< InterestRate > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< InterestRate,std::allocator< InterestRate > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__append(std::vector< InterestRate > *self,std::vector< InterestRate >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< InterestRate >::iterator std_vector_Sl_InterestRate_Sg__erase__SWIG_0(std::vector< InterestRate > *self,std::vector< InterestRate >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< InterestRate >::iterator std_vector_Sl_InterestRate_Sg__erase__SWIG_1(std::vector< InterestRate > *self,std::vector< InterestRate >::iterator first,std::vector< InterestRate >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< InterestRate >::iterator std_vector_Sl_InterestRate_Sg__insert__SWIG_0(std::vector< InterestRate > *self,std::vector< InterestRate >::iterator pos,std::vector< InterestRate >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_InterestRate_Sg__insert__SWIG_1(std::vector< InterestRate > *self,std::vector< InterestRate >::iterator pos,std::vector< InterestRate >::size_type n,std::vector< InterestRate >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Observer;
using QuantLib::Observable;


struct SWIG_null_deleter {
  void operator() (void const *) const {
  }
};
#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
#define SWIG_NO_NULL_DELETER_1
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN


#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT


// C++ wrapper for Python observer
class PyObserver : public Observer {
  public:
    PyObserver(PyObject* callback)
    : callback_(callback) {
        /* make sure the Python object stays alive
           as long as we need it */
        Py_XINCREF(callback_);
    }
    PyObserver(const PyObserver& o)
    : callback_(o.callback_) {
        /* make sure the Python object stays alive
           as long as we need it */
        Py_XINCREF(callback_);
    }
    PyObserver& operator=(const PyObserver& o) {
        if ((this != &o) && (callback_ != o.callback_)) {
            Py_XDECREF(callback_);
            callback_ = o.callback_;
            Py_XINCREF(callback_);
        }
        return *this;
    }
    ~PyObserver() {
        // now it can go as far as we are concerned
        Py_XDECREF(callback_);
    }
    void update() {
        PyObject* pyResult = PyObject_CallFunction(callback_,NULL);
        QL_ENSURE(pyResult != NULL, "failed to notify Python observer");
        Py_XDECREF(pyResult);
    }
  private:
    PyObject* callback_;
};


using QuantLib::Array;
using QuantLib::Matrix;
using QuantLib::SampledCurve;


bool ArrayFromSequence(PyObject* source, Array* target) {
    if (PyTuple_Check(source) || PyList_Check(source)) {
        Size size = (PyTuple_Check(source) ?
                     PyTuple_Size(source) :
                     PyList_Size(source));
        *target = Array(size);
        for (Size i=0; i<size; i++) {
            PyObject* o = PySequence_GetItem(source,i);
            if (PyFloat_Check(o)) {
                (*target)[i] = PyFloat_AsDouble(o);
                Py_DECREF(o);
            } else if (PyInt_Check(o)) {
                (*target)[i] = Real(PyInt_AsLong(o));
                Py_DECREF(o);
            } else {
                Py_DECREF(o);
                return false;
            }
        }
        return true;
    } else {
        return false;
    }
}

SWIGINTERN std::string Array___str__(Array *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN Array Array___add__(Array *self,Array const &a){
            return Array(*self+a);
        }
SWIGINTERN Array Array___sub__(Array *self,Array const &a){
            return Array(*self-a);
        }
SWIGINTERN Array Array___mul____SWIG_0(Array *self,Real a){
            return Array(*self*a);
        }
SWIGINTERN Real Array___mul____SWIG_1(Array *self,Array const &a){
            return QuantLib::DotProduct(*self,a);
        }
SWIGINTERN Array Array___mul____SWIG_2(Array *self,Matrix const &a){
            return *self*a;
        }
SWIGINTERN Array Array___div__(Array *self,Real a){
            return Array(*self/a);
        }
SWIGINTERN Array Array___rmul__(Array *self,Real a){
            return Array(*self*a);
        }
SWIGINTERN Array Array___getslice__(Array *self,Integer i,Integer j){
            Integer size_ = static_cast<Integer>(self->size());
            if (i<0)
                i = size_+i;
            if (j<0)
                j = size_+j;
            i = std::max(0,i);
            j = std::min(size_,j);
            Array tmp(j-i);
            std::copy(self->begin()+i,self->begin()+j,tmp.begin());
            return tmp;
        }
SWIGINTERN void Array___setslice__(Array *self,Integer i,Integer j,Array const &rhs){
            Integer size_ = static_cast<Integer>(self->size());
            if (i<0)
                i = size_+i;
            if (j<0)
                j = size_+j;
            i = std::max(0,i);
            j = std::min(size_,j);
            QL_ENSURE(static_cast<Integer>(rhs.size()) == j-i,
                      "arrays are not resizable");
            std::copy(rhs.begin(),rhs.end(),self->begin()+i);
        }
SWIGINTERN bool Array___nonzero__(Array *self){
            return (self->size() != 0);
        }
SWIGINTERN bool Array___bool__(Array *self){
            return (self->size() != 0);
        }
SWIGINTERN Real Array___getitem__(Array *self,Integer i){
            Integer size_ = static_cast<Integer>(self->size());
            if (i>=0 && i<size_) {
                return (*self)[i];
            } else if (i<0 && -i<=size_) {
                return (*self)[size_+i];
            } else {
                throw std::out_of_range("array index out of range");
            }
        }
SWIGINTERN void Array___setitem__(Array *self,Integer i,Real x){
            Integer size_ = static_cast<Integer>(self->size());
            if (i>=0 && i<size_) {
                (*self)[i] = x;
            } else if (i<0 && -i<=size_) {
                (*self)[size_+i] = x;
            } else {
                throw std::out_of_range("array index out of range");
            }
        }

using QuantLib::outerProduct;
using QuantLib::transpose;
using QuantLib::SVD;


class MatrixRow {
    Matrix::row_iterator begin_;
    Integer columns_;
  public:
    MatrixRow(Matrix::row_iterator begin, Size columns) : begin_(begin), columns_((Integer)columns) {}
    Real __getitem__(Integer i) {
        if (i >= 0 && i < columns_)
            return begin_[i];
        else if (i < 0 && -i <= columns_)
            return begin_[columns_+i];
        else
            throw std::out_of_range("matrix indexes out of range");
    }
    void __setitem__(Integer i, Real x) {
        if (i >= 0 && i < columns_)
            begin_[i] = x;
        else if (i < 0 && -i <= columns_)
            begin_[columns_+i] = x;
        else
            throw std::out_of_range("matrix indexes out of range");
    }
};

SWIGINTERN std::string Matrix___str__(Matrix *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN Matrix Matrix___add__(Matrix *self,Matrix const &m){
            return *self+m;
        }
SWIGINTERN Matrix Matrix___sub__(Matrix *self,Matrix const &m){
            return *self-m;
        }
SWIGINTERN Matrix Matrix___mul____SWIG_0(Matrix *self,Real x){
            return *self*x;
        }
SWIGINTERN Array Matrix___mul____SWIG_1(Matrix *self,Array const &x){
            return *self*x;
        }
SWIGINTERN Matrix Matrix___mul____SWIG_2(Matrix *self,Matrix const &x){
            return *self*x;
        }
SWIGINTERN Matrix Matrix___div__(Matrix *self,Real x){
            return *self/x;
        }
SWIGINTERN MatrixRow Matrix___getitem__(Matrix *self,Integer i){
            Integer rows_ = static_cast<Integer>(self->rows());
            if (i >= 0 && i < self->rows())
                return MatrixRow((*self)[i], self->columns());
            else if (i < 0 && -i <= rows_)
                return MatrixRow((*self)[rows_+i], self->columns());
            else
                throw std::out_of_range("matrix indexes out of range");
        }
SWIGINTERN Matrix Matrix___rmul____SWIG_0(Matrix *self,Real x){
            return x*(*self);
        }
SWIGINTERN Array Matrix___rmul____SWIG_1(Matrix *self,Array const &x){
            return x*(*self);
        }
SWIGINTERN Matrix Matrix___rmul____SWIG_2(Matrix *self,Matrix const &x){
            return x*(*self);
        }

using QuantLib::inverse;
using QuantLib::pseudoSqrt;
using QuantLib::SalvagingAlgorithm;


using QuantLib::BiCGstab;
using QuantLib::GMRES;


Array extractArray(PyObject* source, const std::string& methodName) {
    QL_ENSURE(source != NULL,
              "failed to call " + methodName + " on Python object");

    QL_ENSURE(source != Py_None, methodName + " returned None");
        
    Array* ptr;            
    const int err = SWIG_ConvertPtr(
        source, (void **) &ptr, SWIGTYPE_p_Array, SWIG_POINTER_EXCEPTION);

    if (err != 0) {
        Py_XDECREF(source);
        QL_FAIL("return type must be of type QuantLib Array in " 
            + methodName);
    }
    
    Array tmp(*ptr);          
    Py_XDECREF(source);
     
    return tmp;
}

class MatrixMultiplicationProxy {
  public:
    MatrixMultiplicationProxy(PyObject* matrixMult)
    : matrixMult_(matrixMult) {
        Py_XINCREF(matrixMult_);    
    }
    
    MatrixMultiplicationProxy(const MatrixMultiplicationProxy& p) 
    : matrixMult_(p.matrixMult_) {
        Py_XINCREF(matrixMult_);
    }
        
    MatrixMultiplicationProxy& operator=(const MatrixMultiplicationProxy& f) {
        if ((this != &f) && (matrixMult_ != f.matrixMult_)) {
            Py_XDECREF(matrixMult_);
            matrixMult_ = f.matrixMult_;
            Py_XINCREF(matrixMult_);
        }
        return *this;
    }
        
    ~MatrixMultiplicationProxy() {
        Py_XDECREF(matrixMult_);    
    }
    
    Array operator()(const Array& x) const {
        PyObject* pyArray = SWIG_NewPointerObj(
            SWIG_as_voidptr(&x), SWIGTYPE_p_Array, 0);
            
        PyObject* pyResult 
            = PyObject_CallFunction(matrixMult_, "O", pyArray);
        
        Py_XDECREF(pyArray);
        
        return extractArray(pyResult, "matrix multiplication");         
    }
    
  private:
    PyObject* matrixMult_;      
};

SWIGINTERN Array MatrixMultiplicationProxy_operator_Sp__SP_(MatrixMultiplicationProxy const *self,Array const &x){
	    	Array retVal = self->operator()(x);
	    	return retVal;
	    }
SWIGINTERN Array BiCGstab_solve__SWIG_0(BiCGstab const *self,Array const &b,Array const &x0=Array()){
                return self->solve(b, x0).x; 
        }
SWIGINTERN BiCGstab *new_BiCGstab__SWIG_0(MatrixMultiplicationProxy const &proxy,Size maxIter,Real relTol){              
            return new BiCGstab(BiCGstab::MatrixMult(proxy), maxIter, relTol);                       
        }
SWIGINTERN BiCGstab *new_BiCGstab__SWIG_1(MatrixMultiplicationProxy const &proxy,Size maxIter,Real relTol,MatrixMultiplicationProxy const &preconditioner){              
            return new BiCGstab(
                BiCGstab::MatrixMult(proxy), maxIter, relTol,
                BiCGstab::MatrixMult(preconditioner));                       
        }
SWIGINTERN Array GMRES_solve__SWIG_0(GMRES const *self,Array const &b,Array const &x0=Array()){
            return self->solve(b, x0).x;
        }
SWIGINTERN Array GMRES_solveWithRestart__SWIG_0(GMRES const *self,Size restart,Array const &b,Array const &x0=Array()){
            return self->solveWithRestart(restart, b, x0).x;
        }
SWIGINTERN GMRES *new_GMRES__SWIG_0(MatrixMultiplicationProxy const &proxy,Size maxIter,Real relTol){              
            return new GMRES(GMRES::MatrixMult(proxy), maxIter, relTol);                       
        }
SWIGINTERN GMRES *new_GMRES__SWIG_1(MatrixMultiplicationProxy const &proxy,Size maxIter,Real relTol,MatrixMultiplicationProxy const &preconditioner){              
            return new GMRES(
                GMRES::MatrixMult(proxy), maxIter, relTol,
                GMRES::MatrixMult(preconditioner));                       
        }

using QuantLib::close;
using QuantLib::close_enough;


using QuantLib::CostFunction;


class UnaryFunction {
  public:
    UnaryFunction(PyObject* function) : function_(function) {
        Py_XINCREF(function_);
    }
    UnaryFunction(const UnaryFunction& f) : function_(f.function_) {
        Py_XINCREF(function_);
    }
    UnaryFunction& operator=(const UnaryFunction& f) {
        if ((this != &f) && (function_ != f.function_)) {
            Py_XDECREF(function_);
            function_ = f.function_;
            Py_XINCREF(function_);
        }
        return *this;
    }
    ~UnaryFunction() {
        Py_XDECREF(function_);
    }
    Real operator()(Real x) const {
        PyObject* pyResult = PyObject_CallFunction(function_,"d",x);
        QL_ENSURE(pyResult != NULL, "failed to call Python function");
        Real result = PyFloat_AsDouble(pyResult);
        Py_XDECREF(pyResult);
        return result;
    }
    Real derivative(Real x) const {
        PyObject* pyResult =
            PyObject_CallMethod(function_,"derivative","d",x);
        QL_ENSURE(pyResult != NULL,
                  "failed to call derivative() on Python object");
        Real result = PyFloat_AsDouble(pyResult);
        Py_XDECREF(pyResult);
        return result;
    }
  private:
    PyObject* function_;
};

class BinaryFunction {
  public:
    BinaryFunction(PyObject* function) : function_(function) {
        Py_XINCREF(function_);
    }
    BinaryFunction(const BinaryFunction& f)
    : function_(f.function_) {
        Py_XINCREF(function_);
    }
    BinaryFunction& operator=(const BinaryFunction& f) {
        if ((this != &f) && (function_ != f.function_)) {
            Py_XDECREF(function_);
            function_ = f.function_;
            Py_XINCREF(function_);
        }
        return *this;
    }
    ~BinaryFunction() {
        Py_XDECREF(function_);
    }
    Real operator()(Real x, Real y) const {
        PyObject* pyResult = PyObject_CallFunction(function_,"dd",x,y);
        QL_ENSURE(pyResult != NULL, "failed to call Python function");
        Real result = PyFloat_AsDouble(pyResult);
        Py_XDECREF(pyResult);
        return result;
    }
  private:
    PyObject* function_;
};

class PyCostFunction : public CostFunction {
  public:
    PyCostFunction(PyObject* function) : function_(function) {
        Py_XINCREF(function_);
    }
    PyCostFunction(const PyCostFunction& f)
    : function_(f.function_) {
        Py_XINCREF(function_);
    }
    PyCostFunction& operator=(const PyCostFunction& f) {
        if ((this != &f) && (function_ != f.function_)) {
            Py_XDECREF(function_);
            function_ = f.function_;
            Py_XINCREF(function_);
        }
        return *this;
    }
    ~PyCostFunction() {
        Py_XDECREF(function_);
    }
    Real value(const Array& x) const {
        PyObject* tuple = PyTuple_New(x.size());
        for (Size i=0; i<x.size(); i++)
            PyTuple_SetItem(tuple,i,PyFloat_FromDouble(x[i]));
        PyObject* pyResult = PyObject_CallObject(function_,tuple);
        Py_XDECREF(tuple);
        QL_ENSURE(pyResult != NULL, "failed to call Python function");
        Real result = PyFloat_AsDouble(pyResult);
        Py_XDECREF(pyResult);
        return result;
    }
    Array values(const Array& x) const {
        QL_FAIL("Not implemented");
        // Should be straight forward to copy from a python list
        // to an array
    }
  private:
    PyObject* function_;
};


using QuantLib::Quote;

SWIGINTERN bool Handle_Sl_Quote_Sg____nonzero__(Handle< Quote > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_Quote_Sg____bool__(Handle< Quote > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_Quote_Sg__asObservable(Handle< Quote > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_Quote_Sg__reset(RelinkableHandle< Quote > *self){
            self->linkTo(ext::shared_ptr<Quote>());
        }

using QuantLib::SimpleQuote;
using QuantLib::LastFixingQuote;


using QuantLib::DerivedQuote;
using QuantLib::CompositeQuote;

SWIGINTERN DerivedQuote< UnaryFunction > *new_DerivedQuote_Sl_UnaryFunction_Sg_(Handle< Quote > const &h,PyObject *function){
            return new DerivedQuote<UnaryFunction>(h,UnaryFunction(function));
        }
SWIGINTERN CompositeQuote< BinaryFunction > *new_CompositeQuote_Sl_BinaryFunction_Sg_(Handle< Quote > const &h1,Handle< Quote > const &h2,PyObject *function){
            return new CompositeQuote<BinaryFunction>(h1,h2,BinaryFunction(function));
        }

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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< Quote >, std::allocator< ext::shared_ptr< Quote > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< Quote >" "," "std::allocator< ext::shared_ptr< Quote > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__iterator(std::vector< ext::shared_ptr< Quote > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< Quote > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____bool__(std::vector< ext::shared_ptr< Quote > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< Quote > >::size_type std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____len__(std::vector< ext::shared_ptr< Quote > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____getslice__(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::difference_type i,std::vector< ext::shared_ptr< Quote > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::difference_type i,std::vector< ext::shared_ptr< Quote > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::difference_type i,std::vector< ext::shared_ptr< Quote > >::difference_type j,std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____delslice__(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::difference_type i,std::vector< ext::shared_ptr< Quote > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< Quote > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< Quote > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< Quote > > const *self,std::vector< ext::shared_ptr< Quote > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::difference_type i,std::vector< ext::shared_ptr< Quote > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< Quote > >::value_type std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__pop(std::vector< ext::shared_ptr< Quote > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__append(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< Quote > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< Quote > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::iterator first,std::vector< ext::shared_ptr< Quote > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< Quote > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::iterator pos,std::vector< ext::shared_ptr< Quote > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< Quote > > *self,std::vector< ext::shared_ptr< Quote > >::iterator pos,std::vector< ext::shared_ptr< Quote > >::size_type n,std::vector< ext::shared_ptr< Quote > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >, std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >" "," "std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__iterator(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____nonzero__(std::vector< std::vector< ext::shared_ptr< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____bool__(std::vector< std::vector< ext::shared_ptr< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____len__(std::vector< std::vector< ext::shared_ptr< Quote > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getslice__(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j,std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delslice__(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1(std::vector< std::vector< ext::shared_ptr< Quote > > > const *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__pop(std::vector< std::vector< ext::shared_ptr< Quote > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__append(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator first,std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(std::vector< std::vector< ext::shared_ptr< Quote > > > *self,std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos,std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< Handle< Quote >, std::allocator< Handle< Quote > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Handle< Quote >" "," "std::allocator< Handle< Quote > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Handle_Sl_Quote_Sg__Sg__iterator(std::vector< Handle< Quote > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Handle_Sl_Quote_Sg__Sg____nonzero__(std::vector< Handle< Quote > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Handle_Sl_Quote_Sg__Sg____bool__(std::vector< Handle< Quote > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Handle< Quote > >::size_type std_vector_Sl_Handle_Sl_Quote_Sg__Sg____len__(std::vector< Handle< Quote > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *std_vector_Sl_Handle_Sl_Quote_Sg__Sg____getslice__(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::difference_type i,std::vector< Handle< Quote > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setslice____SWIG_0(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::difference_type i,std::vector< Handle< Quote > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >());
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setslice____SWIG_1(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::difference_type i,std::vector< Handle< Quote > >::difference_type j,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____delslice__(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::difference_type i,std::vector< Handle< Quote > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____delitem____SWIG_0(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *std_vector_Sl_Handle_Sl_Quote_Sg__Sg____getitem____SWIG_0(std::vector< Handle< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type id = i;
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setitem____SWIG_0(std::vector< Handle< Quote > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type id = i;
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setitem____SWIG_1(std::vector< Handle< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type id = i;
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____delitem____SWIG_1(std::vector< Handle< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type id = i;
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Handle< Quote > >::value_type const &std_vector_Sl_Handle_Sl_Quote_Sg__Sg____getitem____SWIG_1(std::vector< Handle< Quote > > const *self,std::vector< Handle< Quote > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setitem____SWIG_2(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::difference_type i,std::vector< Handle< Quote > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Handle< Quote > >::value_type std_vector_Sl_Handle_Sl_Quote_Sg__Sg__pop(std::vector< Handle< Quote > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__append(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Handle< Quote > >::iterator std_vector_Sl_Handle_Sl_Quote_Sg__Sg__erase__SWIG_0(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Handle< Quote > >::iterator std_vector_Sl_Handle_Sl_Quote_Sg__Sg__erase__SWIG_1(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::iterator first,std::vector< Handle< Quote > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Handle< Quote > >::iterator std_vector_Sl_Handle_Sl_Quote_Sg__Sg__insert__SWIG_0(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::iterator pos,std::vector< Handle< Quote > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Handle_Sl_Quote_Sg__Sg__insert__SWIG_1(std::vector< Handle< Quote > > *self,std::vector< Handle< Quote > >::iterator pos,std::vector< Handle< Quote > >::size_type n,std::vector< Handle< Quote > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >, std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >" "," "std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__iterator(std::vector< std::vector< Handle< Quote > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____nonzero__(std::vector< std::vector< Handle< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____bool__(std::vector< std::vector< Handle< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< Handle< Quote > > >::size_type std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____len__(std::vector< std::vector< Handle< Quote > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____getslice__(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::difference_type i,std::vector< std::vector< Handle< Quote > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::difference_type i,std::vector< std::vector< Handle< Quote > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::difference_type i,std::vector< std::vector< Handle< Quote > > >::difference_type j,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____delslice__(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::difference_type i,std::vector< std::vector< Handle< Quote > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(std::vector< std::vector< Handle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(std::vector< std::vector< Handle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(std::vector< std::vector< Handle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(std::vector< std::vector< Handle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< Handle< Quote > > >::value_type const &std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1(std::vector< std::vector< Handle< Quote > > > const *self,std::vector< std::vector< Handle< Quote > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::difference_type i,std::vector< std::vector< Handle< Quote > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< Handle< Quote > > >::value_type std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__pop(std::vector< std::vector< Handle< Quote > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__append(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< Handle< Quote > > >::iterator std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< Handle< Quote > > >::iterator std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::iterator first,std::vector< std::vector< Handle< Quote > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< Handle< Quote > > >::iterator std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::iterator pos,std::vector< std::vector< Handle< Quote > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(std::vector< std::vector< Handle< Quote > > > *self,std::vector< std::vector< Handle< Quote > > >::iterator pos,std::vector< std::vector< Handle< Quote > > >::size_type n,std::vector< std::vector< Handle< Quote > > >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< RelinkableHandle< Quote >, std::allocator< RelinkableHandle< Quote > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "RelinkableHandle< Quote >" "," "std::allocator< RelinkableHandle< Quote > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__iterator(std::vector< RelinkableHandle< Quote > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____nonzero__(std::vector< RelinkableHandle< Quote > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____bool__(std::vector< RelinkableHandle< Quote > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< RelinkableHandle< Quote > >::size_type std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____len__(std::vector< RelinkableHandle< Quote > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____getslice__(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::difference_type i,std::vector< RelinkableHandle< Quote > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setslice____SWIG_0(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::difference_type i,std::vector< RelinkableHandle< Quote > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >());
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setslice____SWIG_1(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::difference_type i,std::vector< RelinkableHandle< Quote > >::difference_type j,std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____delslice__(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::difference_type i,std::vector< RelinkableHandle< Quote > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____delitem____SWIG_0(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____getitem____SWIG_0(std::vector< RelinkableHandle< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type id = i;
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setitem____SWIG_0(std::vector< RelinkableHandle< Quote > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type id = i;
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setitem____SWIG_1(std::vector< RelinkableHandle< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type id = i;
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____delitem____SWIG_1(std::vector< RelinkableHandle< Quote > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type id = i;
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< RelinkableHandle< Quote > >::value_type const &std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____getitem____SWIG_1(std::vector< RelinkableHandle< Quote > > const *self,std::vector< RelinkableHandle< Quote > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setitem____SWIG_2(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::difference_type i,std::vector< RelinkableHandle< Quote > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< RelinkableHandle< Quote > >::value_type std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__pop(std::vector< RelinkableHandle< Quote > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__append(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< RelinkableHandle< Quote > >::iterator std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__erase__SWIG_0(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< RelinkableHandle< Quote > >::iterator std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__erase__SWIG_1(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::iterator first,std::vector< RelinkableHandle< Quote > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< RelinkableHandle< Quote > >::iterator std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__insert__SWIG_0(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::iterator pos,std::vector< RelinkableHandle< Quote > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__insert__SWIG_1(std::vector< RelinkableHandle< Quote > > *self,std::vector< RelinkableHandle< Quote > >::iterator pos,std::vector< RelinkableHandle< Quote > >::size_type n,std::vector< RelinkableHandle< Quote > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >, std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >" "," "std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__iterator(std::vector< std::vector< RelinkableHandle< Quote > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____nonzero__(std::vector< std::vector< RelinkableHandle< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____bool__(std::vector< std::vector< RelinkableHandle< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > >::size_type std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____len__(std::vector< std::vector< RelinkableHandle< Quote > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____getslice__(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j,std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____delslice__(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type id = i;
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > const *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > >::value_type std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__pop(std::vector< std::vector< RelinkableHandle< Quote > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__append(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > >::iterator std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > >::iterator std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::iterator first,std::vector< std::vector< RelinkableHandle< Quote > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< RelinkableHandle< Quote > > >::iterator std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(std::vector< std::vector< RelinkableHandle< Quote > > > *self,std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos,std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Bisection;
using QuantLib::Brent;
using QuantLib::FalsePosition;
using QuantLib::Newton;
using QuantLib::NewtonSafe;
using QuantLib::Ridder;
using QuantLib::Secant;

SWIGINTERN Real Brent_solve__SWIG_0(Brent *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Brent_solve__SWIG_1(Brent *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Bisection_solve__SWIG_0(Bisection *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Bisection_solve__SWIG_1(Bisection *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real FalsePosition_solve__SWIG_0(FalsePosition *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real FalsePosition_solve__SWIG_1(FalsePosition *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Ridder_solve__SWIG_0(Ridder *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Ridder_solve__SWIG_1(Ridder *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Secant_solve__SWIG_0(Secant *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Secant_solve__SWIG_1(Secant *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real Newton_solve__SWIG_0(Newton *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real Newton_solve__SWIG_1(Newton *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }
SWIGINTERN Real NewtonSafe_solve__SWIG_0(NewtonSafe *self,PyObject *function,Real xAccuracy,Real guess,Real step){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, step);
        }
SWIGINTERN Real NewtonSafe_solve__SWIG_1(NewtonSafe *self,PyObject *function,Real xAccuracy,Real guess,Real xMin,Real xMax){
            UnaryFunction f(function);
            return self->solve(f, xAccuracy, guess, xMin, xMax);
        }

using QuantLib::Constraint;
using QuantLib::BoundaryConstraint;
using QuantLib::NoConstraint;
using QuantLib::PositiveConstraint;
using QuantLib::CompositeConstraint;
using QuantLib::NonhomogeneousBoundaryConstraint;


using QuantLib::EndCriteria;


using QuantLib::OptimizationMethod;
using QuantLib::ConjugateGradient;
using QuantLib::Simplex;
using QuantLib::SteepestDescent;
using QuantLib::BFGS;
using QuantLib::LevenbergMarquardt;
using QuantLib::DifferentialEvolution;
using QuantLib::SamplerGaussian;
using QuantLib::SamplerLogNormal;
using QuantLib::SamplerMirrorGaussian;
using QuantLib::ProbabilityBoltzmannDownhill;
using QuantLib::TemperatureExponential;
using QuantLib::ReannealingTrivial;
using QuantLib::GaussianSimulatedAnnealing;
using QuantLib::MirrorGaussianSimulatedAnnealing;
using QuantLib::LogNormalSimulatedAnnealing;



using QuantLib::Problem;


    class Optimizer {};

SWIGINTERN Array Optimizer_solve(Optimizer *self,PyObject *function,Constraint &c,OptimizationMethod &m,EndCriteria &e,Array &iv){
        PyCostFunction f(function);
        Problem p(f,c,iv);
        m.minimize(p, e);
        return p.currentValue();
    }

// safe versions which copy their arguments
template <class I>
class SafeInterpolation {
  public:
    SafeInterpolation(const Array& x, const Array& y)
    : x_(x), y_(y), f_(x_.begin(),x_.end(),y_.begin()) {}
    Real operator()(Real x, bool allowExtrapolation=false) {
        return f_(x, allowExtrapolation);
    }
    Array x_, y_;
    I f_;
};


typedef SafeInterpolation<QuantLib::LinearInterpolation> SafeLinearInterpolation;


typedef SafeInterpolation<QuantLib::LogLinearInterpolation> SafeLogLinearInterpolation;


typedef SafeInterpolation<QuantLib::BackwardFlatInterpolation> SafeBackwardFlatInterpolation;


typedef SafeInterpolation<QuantLib::ForwardFlatInterpolation> SafeForwardFlatInterpolation;


typedef SafeInterpolation<QuantLib::CubicNaturalSpline> SafeCubicNaturalSpline;

SWIGINTERN Real SafeCubicNaturalSpline_derivative__SWIG_0(SafeCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeCubicNaturalSpline_secondDerivative__SWIG_0(SafeCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeCubicNaturalSpline_primitive__SWIG_0(SafeCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::LogCubicNaturalSpline> SafeLogCubicNaturalSpline;

SWIGINTERN Real SafeLogCubicNaturalSpline_derivative__SWIG_0(SafeLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogCubicNaturalSpline_secondDerivative__SWIG_0(SafeLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogCubicNaturalSpline_primitive__SWIG_0(SafeLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicCubicNaturalSpline> SafeMonotonicCubicNaturalSpline;

SWIGINTERN Real SafeMonotonicCubicNaturalSpline_derivative__SWIG_0(SafeMonotonicCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicCubicNaturalSpline_secondDerivative__SWIG_0(SafeMonotonicCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicCubicNaturalSpline_primitive__SWIG_0(SafeMonotonicCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicLogCubicNaturalSpline> SafeMonotonicLogCubicNaturalSpline;

SWIGINTERN Real SafeMonotonicLogCubicNaturalSpline_derivative__SWIG_0(SafeMonotonicLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(SafeMonotonicLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogCubicNaturalSpline_primitive__SWIG_0(SafeMonotonicLogCubicNaturalSpline *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::KrugerCubic> SafeKrugerCubic;

SWIGINTERN Real SafeKrugerCubic_derivative__SWIG_0(SafeKrugerCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerCubic_secondDerivative__SWIG_0(SafeKrugerCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerCubic_primitive__SWIG_0(SafeKrugerCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::KrugerLogCubic> SafeKrugerLogCubic;

SWIGINTERN Real SafeKrugerLogCubic_derivative__SWIG_0(SafeKrugerLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerLogCubic_secondDerivative__SWIG_0(SafeKrugerLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeKrugerLogCubic_primitive__SWIG_0(SafeKrugerLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::FritschButlandCubic> SafeFritschButlandCubic;

SWIGINTERN Real SafeFritschButlandCubic_derivative__SWIG_0(SafeFritschButlandCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandCubic_secondDerivative__SWIG_0(SafeFritschButlandCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandCubic_primitive__SWIG_0(SafeFritschButlandCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::FritschButlandLogCubic> SafeFritschButlandLogCubic;

SWIGINTERN Real SafeFritschButlandLogCubic_derivative__SWIG_0(SafeFritschButlandLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandLogCubic_secondDerivative__SWIG_0(SafeFritschButlandLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeFritschButlandLogCubic_primitive__SWIG_0(SafeFritschButlandLogCubic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::Parabolic> SafeParabolic;

SWIGINTERN Real SafeParabolic_derivative__SWIG_0(SafeParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeParabolic_secondDerivative__SWIG_0(SafeParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeParabolic_primitive__SWIG_0(SafeParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::LogParabolic> SafeLogParabolic;

SWIGINTERN Real SafeLogParabolic_derivative__SWIG_0(SafeLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogParabolic_secondDerivative__SWIG_0(SafeLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeLogParabolic_primitive__SWIG_0(SafeLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicParabolic> SafeMonotonicParabolic;

SWIGINTERN Real SafeMonotonicParabolic_derivative__SWIG_0(SafeMonotonicParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicParabolic_secondDerivative__SWIG_0(SafeMonotonicParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicParabolic_primitive__SWIG_0(SafeMonotonicParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::MonotonicLogParabolic> SafeMonotonicLogParabolic;

SWIGINTERN Real SafeMonotonicLogParabolic_derivative__SWIG_0(SafeMonotonicLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.derivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogParabolic_secondDerivative__SWIG_0(SafeMonotonicLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.secondDerivative(x,extrapolate);
    }
SWIGINTERN Real SafeMonotonicLogParabolic_primitive__SWIG_0(SafeMonotonicLogParabolic *self,Real x,bool extrapolate=false){
        return self->f_.primitive(x,extrapolate);
    }

typedef SafeInterpolation<QuantLib::LagrangeInterpolation> SafeLagrangeInterpolation;


// safe versions which copy their arguments
template <class I>
class SafeInterpolation2D {
  public:
    SafeInterpolation2D(const Array& x, const Array& y, const Matrix& m)
    : x_(x), y_(y), m_(m), f_(x_.begin(),x_.end(),y_.begin(),y_.end(),m_) {}
    Real operator()(Real x, Real y, bool allowExtrapolation=false) {
        return f_(x,y, allowExtrapolation);
    }
  protected:
    Array x_, y_;
    Matrix m_;
    I f_;
};


typedef SafeInterpolation2D<QuantLib::BilinearInterpolation> SafeBilinearInterpolation;


typedef SafeInterpolation2D<QuantLib::BicubicSpline> SafeBicubicSpline;


using QuantLib::CubicInterpolation;
using QuantLib::MixedInterpolation;
using QuantLib::BackwardFlat;
using QuantLib::ForwardFlat;
using QuantLib::Linear;
using QuantLib::LogLinear;
using QuantLib::Cubic;
using QuantLib::Bicubic;
using QuantLib::ConvexMonotone;
using QuantLib::DefaultLogCubic;
using QuantLib::MonotonicLogCubic;
using QuantLib::KrugerLog;

class MonotonicCubic : public Cubic {
  public:
    MonotonicCubic()
    : Cubic(CubicInterpolation::Spline, true,
            CubicInterpolation::SecondDerivative, 0.0,
            CubicInterpolation::SecondDerivative, 0.0) {}
};

class SplineCubic : public Cubic {
  public:
    SplineCubic()
    : Cubic(CubicInterpolation::Spline, false,
            CubicInterpolation::SecondDerivative, 0.0,
            CubicInterpolation::SecondDerivative, 0.0) {}
};

class Kruger : public Cubic {
  public:
    Kruger()
    : Cubic(CubicInterpolation::Kruger) {}
};

class SplineLogCubic : public QuantLib::LogCubic {
  public:
    SplineLogCubic()
    : QuantLib::LogCubic(CubicInterpolation::Spline, false,
                         CubicInterpolation::SecondDerivative, 0.0,
                         CubicInterpolation::SecondDerivative, 0.0) {}
};

class LogMixedLinearCubic : public QuantLib::LogMixedLinearCubic {
  public:
    // We add defaults for all constructor arguments because wrappers for
    // InterpolatedDiscountCurve and PiecewiseYieldCurve assume that all
    // interpolators have default constructors.
    LogMixedLinearCubic(
        Size n = 0,
        MixedInterpolation::Behavior behavior = MixedInterpolation::ShareRanges,
        CubicInterpolation::DerivativeApprox da = CubicInterpolation::Spline,
        bool monotonic = true)
    : QuantLib::LogMixedLinearCubic(n, behavior, da, monotonic) {}
};


// safe version which copies its arguments
class SafeSABRInterpolation {
  public:
    SafeSABRInterpolation(const Array& x, const Array& y,
                          Time t,
                          Real forward,
                          Real alpha,
                          Real beta,
                          Real nu,
                          Real rho,
                          bool alphaIsFixed = false,
                          bool betaIsFixed = false,
                          bool nuIsFixed = false,
                          bool rhoIsFixed = false,
                          bool vegaWeighted = true,
                          const ext::shared_ptr<EndCriteria>& endCriteria
                                  = ext::shared_ptr<EndCriteria>(),
                          const ext::shared_ptr<OptimizationMethod>& optMethod
                                  = ext::shared_ptr<OptimizationMethod>(),
                          const Real errorAccept=0.0020,
                          const bool useMaxError=false,
                          const Size maxGuesses=50,
                          const Real shift = 0.0)
    : x_(x), y_(y), forward_(forward),
      f_(x_.begin(),x_.end(),y_.begin(),
         t, forward_, alpha, beta, nu, rho,
         alphaIsFixed, betaIsFixed,
         nuIsFixed, rhoIsFixed,
         vegaWeighted, endCriteria, optMethod,
         errorAccept, useMaxError, maxGuesses, shift) {f_.update();}
    Real operator()(Real x, bool allowExtrapolation=false) const {
        return f_(x, allowExtrapolation);
    }
    Real alpha() const {return f_.alpha();}
    Real beta() const {return f_.beta();}
    Real rho() const {return f_.rho();}
    Real nu() const {return f_.nu();}
    
  private:
    Array x_, y_;  // passed via iterators, need to stay alive
    Real forward_; // passed by reference, same
    QuantLib::SABRInterpolation f_;
};


using QuantLib::RichardsonExtrapolation;

SWIGINTERN RichardsonExtrapolation *new_RichardsonExtrapolation__SWIG_0(PyObject *fct,Real delta_h,Real n=Null< Real >()){
        
            UnaryFunction f(fct);
            return new RichardsonExtrapolation(f, delta_h, n); 
        }

class SafeConvexMonotoneInterpolation {
  public:
    SafeConvexMonotoneInterpolation(const Array& x, const Array& y,
                                    Real quadraticity = 0.3,
                                    Real monotonicity = 0.7,
                                    bool forcePositive = true)
    : x_(x), y_(y), f_(x_.begin(), x_.end(), y_.begin(),
                       quadraticity, monotonicity, forcePositive) {}
    Real operator()(Real x, bool allowExtrapolation=false) {
        return f_(x, allowExtrapolation);
    }
    Array x_, y_;
    QuantLib::ConvexMonotoneInterpolation<Array::const_iterator, Array::const_iterator> f_;
};


using QuantLib::ChebyshevInterpolation;

SWIGINTERN ChebyshevInterpolation *new_ChebyshevInterpolation__SWIG_2(Size n,PyObject *fct,ChebyshevInterpolation::PointsType pointsType=ChebyshevInterpolation::SecondKind){
        
            UnaryFunction f(fct);
            return new ChebyshevInterpolation(n, f, pointsType); 
        }

using QuantLib::TermStructure;


using QuantLib::YieldTermStructure;

SWIGINTERN bool Handle_Sl_YieldTermStructure_Sg____nonzero__(Handle< YieldTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_YieldTermStructure_Sg____bool__(Handle< YieldTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_YieldTermStructure_Sg__asObservable(Handle< YieldTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_YieldTermStructure_Sg__reset(RelinkableHandle< YieldTermStructure > *self){
            self->linkTo(ext::shared_ptr<YieldTermStructure>());
        }

using QuantLib::ImpliedTermStructure;


using QuantLib::ZeroSpreadedTermStructure;
using QuantLib::ForwardSpreadedTermStructure;


using PiecewiseZeroSpreadedTermStructure = QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>;


using SpreadedLinearZeroInterpolatedTermStructure = QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure<Linear>;


using SpreadedBackwardFlatZeroInterpolatedTermStructure = QuantLib::InterpolatedPiecewiseZeroSpreadedTermStructure<BackwardFlat>;


using QuantLib::FlatForward;


using QuantLib::UltimateForwardTermStructure;


using QuantLib::CompositeZeroYieldStructure;

SWIGINTERN CompositeZeroYieldStructure< BinaryFunction > *new_CompositeZeroYieldStructure_Sl_BinaryFunction_Sg___SWIG_0(Handle< YieldTermStructure > const &h1,Handle< YieldTermStructure > const &h2,PyObject *function,Compounding comp=QuantLib::Continuous,Frequency freq=QuantLib::NoFrequency){
            return new CompositeZeroYieldStructure<BinaryFunction>(h1, h2, BinaryFunction(function), comp, freq);
        }

using QuantLib::QuantoTermStructure;


using QuantLib::TimeSeries;
using QuantLib::IntervalPrice;

SWIGINTERN TimeSeries< Real > *new_TimeSeries_Sl_Real_Sg___SWIG_1(std::vector< Date,std::allocator< Date > > const &d,std::vector< double,std::allocator< double > > const &v){
            return new TimeSeries<double>(d.begin(), d.end(), v.begin());
        }
SWIGINTERN double TimeSeries_Sl_Real_Sg____getitem__(TimeSeries< Real > *self,Date const &d){
            return (*self)[d];
        }
SWIGINTERN void TimeSeries_Sl_Real_Sg____setitem__(TimeSeries< Real > *self,Date const &d,double const &value){
            (*self)[d] = value;
        }
SWIGINTERN TimeSeries< IntervalPrice > *new_TimeSeries_Sl_IntervalPrice_Sg___SWIG_1(std::vector< Date,std::allocator< Date > > const &d,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &v){
            return new TimeSeries<IntervalPrice>(d.begin(), d.end(), v.begin());
        }
SWIGINTERN IntervalPrice TimeSeries_Sl_IntervalPrice_Sg____getitem__(TimeSeries< IntervalPrice > *self,Date const &d){
            return (*self)[d];
        }
SWIGINTERN void TimeSeries_Sl_IntervalPrice_Sg____setitem__(TimeSeries< IntervalPrice > *self,Date const &d,IntervalPrice const &value){
            (*self)[d] = value;
        }

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


      namespace swig {
	template <>  struct traits<std::vector< IntervalPrice, std::allocator< IntervalPrice > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "IntervalPrice" "," "std::allocator< IntervalPrice >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_IntervalPrice_Sg__iterator(std::vector< IntervalPrice > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_IntervalPrice_Sg____nonzero__(std::vector< IntervalPrice > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_IntervalPrice_Sg____bool__(std::vector< IntervalPrice > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< IntervalPrice >::size_type std_vector_Sl_IntervalPrice_Sg____len__(std::vector< IntervalPrice > const *self){
      return self->size();
    }
SWIGINTERN std::vector< IntervalPrice,std::allocator< IntervalPrice > > *std_vector_Sl_IntervalPrice_Sg____getslice__(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::difference_type i,std::vector< IntervalPrice >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____setslice____SWIG_0(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::difference_type i,std::vector< IntervalPrice >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< IntervalPrice,std::allocator< IntervalPrice > >());
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____setslice____SWIG_1(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::difference_type i,std::vector< IntervalPrice >::difference_type j,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____delslice__(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::difference_type i,std::vector< IntervalPrice >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____delitem____SWIG_0(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< IntervalPrice,std::allocator< IntervalPrice > > *std_vector_Sl_IntervalPrice_Sg____getitem____SWIG_0(std::vector< IntervalPrice > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type id = i;
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____setitem____SWIG_0(std::vector< IntervalPrice > *self,SWIGPY_SLICEOBJECT *slice,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type id = i;
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____setitem____SWIG_1(std::vector< IntervalPrice > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type id = i;
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____delitem____SWIG_1(std::vector< IntervalPrice > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type id = i;
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< IntervalPrice >::value_type const &std_vector_Sl_IntervalPrice_Sg____getitem____SWIG_1(std::vector< IntervalPrice > const *self,std::vector< IntervalPrice >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg____setitem____SWIG_2(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::difference_type i,std::vector< IntervalPrice >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< IntervalPrice >::value_type std_vector_Sl_IntervalPrice_Sg__pop(std::vector< IntervalPrice > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< IntervalPrice,std::allocator< IntervalPrice > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__append(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< IntervalPrice >::iterator std_vector_Sl_IntervalPrice_Sg__erase__SWIG_0(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< IntervalPrice >::iterator std_vector_Sl_IntervalPrice_Sg__erase__SWIG_1(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::iterator first,std::vector< IntervalPrice >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< IntervalPrice >::iterator std_vector_Sl_IntervalPrice_Sg__insert__SWIG_0(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::iterator pos,std::vector< IntervalPrice >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_IntervalPrice_Sg__insert__SWIG_1(std::vector< IntervalPrice > *self,std::vector< IntervalPrice >::iterator pos,std::vector< IntervalPrice >::size_type n,std::vector< IntervalPrice >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::IndexManager;


using QuantLib::Index;

SWIGINTERN void Index_addFixings__SWIG_0(Index *self,std::vector< Date,std::allocator< Date > > const &fixingDates,std::vector< Rate,std::allocator< Rate > > const &fixings,bool forceOverwrite=false){
            self->addFixings(fixingDates.begin(),fixingDates.end(),
                             fixings.begin(),
                             forceOverwrite);
        }
SWIGINTERN std::string Index___str__(Index *self){
            return self->name()+" index";
        }

using QuantLib::InterestRateIndex;


using QuantLib::IborIndex;
using QuantLib::OvernightIndex;


    ext::shared_ptr<IborIndex> as_iborindex(
                          const ext::shared_ptr<InterestRateIndex>& index) {
        return ext::dynamic_pointer_cast<IborIndex>(index);
    }

SWIGINTERN ext::shared_ptr< OvernightIndex > OvernightIndex_clone(OvernightIndex const *self,Handle< YieldTermStructure > const &h){
            return ext::dynamic_pointer_cast<OvernightIndex>(self->clone(h));
        }

using QuantLib::Libor;
using QuantLib::DailyTenorLibor;


using QuantLib::SwapIndex;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< SwapIndex >, std::allocator< ext::shared_ptr< SwapIndex > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< SwapIndex >" "," "std::allocator< ext::shared_ptr< SwapIndex > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__iterator(std::vector< ext::shared_ptr< SwapIndex > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< SwapIndex > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____bool__(std::vector< ext::shared_ptr< SwapIndex > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::size_type std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____len__(std::vector< ext::shared_ptr< SwapIndex > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____getslice__(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i,std::vector< ext::shared_ptr< SwapIndex > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i,std::vector< ext::shared_ptr< SwapIndex > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i,std::vector< ext::shared_ptr< SwapIndex > >::difference_type j,std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____delslice__(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i,std::vector< ext::shared_ptr< SwapIndex > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > const *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::difference_type i,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::value_type std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__pop(std::vector< ext::shared_ptr< SwapIndex > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__append(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::iterator std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::iterator std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::iterator first,std::vector< ext::shared_ptr< SwapIndex > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< SwapIndex > >::iterator std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::iterator pos,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< SwapIndex > > *self,std::vector< ext::shared_ptr< SwapIndex > >::iterator pos,std::vector< ext::shared_ptr< SwapIndex > >::size_type n,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &x){ self->insert(pos, n, x); }

    ext::shared_ptr<SwapIndex> as_swap_index(
                          const ext::shared_ptr<InterestRateIndex>& index) {
        return ext::dynamic_pointer_cast<SwapIndex>(index);
    }


using QuantLib::SwapSpreadIndex;


using QuantLib::EquityIndex;


using QuantLib::AUDLibor;


using QuantLib::CADLibor;


using QuantLib::CADLiborON;


using QuantLib::Cdor;


using QuantLib::CHFLibor;


using QuantLib::DKKLibor;


using QuantLib::Bbsw;


using QuantLib::Bbsw1M;


using QuantLib::Bbsw2M;


using QuantLib::Bbsw3M;


using QuantLib::Bbsw4M;


using QuantLib::Bbsw5M;


using QuantLib::Bbsw6M;


using QuantLib::Bkbm;


using QuantLib::Bkbm1M;


using QuantLib::Bkbm2M;


using QuantLib::Bkbm3M;


using QuantLib::Bkbm4M;


using QuantLib::Bkbm5M;


using QuantLib::Bkbm6M;


using QuantLib::Euribor;


using QuantLib::EuriborSW;


using QuantLib::Euribor2W;


using QuantLib::Euribor3W;


using QuantLib::Euribor1M;


using QuantLib::Euribor2M;


using QuantLib::Euribor3M;


using QuantLib::Euribor4M;


using QuantLib::Euribor5M;


using QuantLib::Euribor6M;


using QuantLib::Euribor7M;


using QuantLib::Euribor8M;


using QuantLib::Euribor9M;


using QuantLib::Euribor10M;


using QuantLib::Euribor11M;


using QuantLib::Euribor1Y;


using QuantLib::Euribor365;


using QuantLib::Euribor365_SW;


using QuantLib::Euribor365_2W;


using QuantLib::Euribor365_3W;


using QuantLib::Euribor365_1M;


using QuantLib::Euribor365_2M;


using QuantLib::Euribor365_3M;


using QuantLib::Euribor365_4M;


using QuantLib::Euribor365_5M;


using QuantLib::Euribor365_6M;


using QuantLib::Euribor365_7M;


using QuantLib::Euribor365_8M;


using QuantLib::Euribor365_9M;


using QuantLib::Euribor365_10M;


using QuantLib::Euribor365_11M;


using QuantLib::Euribor365_1Y;


using QuantLib::EURLibor;


using QuantLib::EURLiborSW;


using QuantLib::EURLibor2W;


using QuantLib::EURLibor1M;


using QuantLib::EURLibor2M;


using QuantLib::EURLibor3M;


using QuantLib::EURLibor4M;


using QuantLib::EURLibor5M;


using QuantLib::EURLibor6M;


using QuantLib::EURLibor7M;


using QuantLib::EURLibor8M;


using QuantLib::EURLibor9M;


using QuantLib::EURLibor10M;


using QuantLib::EURLibor11M;


using QuantLib::EURLibor1Y;


using QuantLib::GBPLibor;


using QuantLib::GBPLiborON;


using QuantLib::Jibar;


using QuantLib::JPYLibor;


using QuantLib::Mosprime;


using QuantLib::NZDLibor;


using QuantLib::Pribor;


using QuantLib::Robor;


using QuantLib::SEKLibor;


using QuantLib::Shibor;


using QuantLib::Tibor;


using QuantLib::THBFIX;


using QuantLib::TRLibor;


using QuantLib::USDLibor;


using QuantLib::USDLiborON;


using QuantLib::Wibor;


using QuantLib::Zibor;


using QuantLib::Aonia;


using QuantLib::Corra;


using QuantLib::Destr;


using QuantLib::Eonia;


using QuantLib::Estr;


using QuantLib::FedFunds;


using QuantLib::Nzocr;


using QuantLib::Sofr;


using QuantLib::Sonia;


using QuantLib::Swestr;


using QuantLib::EuriborSwapIsdaFixA;


using QuantLib::EuriborSwapIsdaFixB;


using QuantLib::EuriborSwapIfrFix;


using QuantLib::EurLiborSwapIsdaFixA;


using QuantLib::EurLiborSwapIsdaFixB;


using QuantLib::EurLiborSwapIfrFix;


using QuantLib::ChfLiborSwapIsdaFix;


using QuantLib::GbpLiborSwapIsdaFix;


using QuantLib::JpyLiborSwapIsdaFixAm;


using QuantLib::JpyLiborSwapIsdaFixPm;


using QuantLib::UsdLiborSwapIsdaFixAm;


using QuantLib::UsdLiborSwapIsdaFixPm;


using QuantLib::Bibor;


using QuantLib::BiborSW;


using QuantLib::Bibor1M;


using QuantLib::Bibor2M;


using QuantLib::Bibor3M;


using QuantLib::Bibor6M;


using QuantLib::Bibor9M;


using QuantLib::Bibor1Y;


using QuantLib::Schedule;
using QuantLib::DateGeneration;
using QuantLib::MakeSchedule;

SWIGINTERN Date Schedule___getitem__(Schedule *self,Integer i){
            Integer size_ = static_cast<Integer>(self->size());
            if (i>=0 && i<size_) {
                return self->date(i);
            } else if (i<0 && -i<=size_) {
                return self->date(size_+i);
            } else {
                throw std::out_of_range("schedule index out of range");
            }
        }
SWIGINTERN Schedule MakeSchedule_schedule(MakeSchedule *self){
        return (Schedule)(* self);
      }

using QuantLib::VolatilityType;
using QuantLib::ShiftedLognormal;
using QuantLib::Normal;


using QuantLib::VolatilityTermStructure;
using QuantLib::BlackVolTermStructure;
using QuantLib::LocalVolTermStructure;
using QuantLib::OptionletVolatilityStructure;
using QuantLib::SwaptionVolatilityStructure;
using QuantLib::YoYOptionletVolatilitySurface;

SWIGINTERN bool Handle_Sl_BlackVolTermStructure_Sg____nonzero__(Handle< BlackVolTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_BlackVolTermStructure_Sg____bool__(Handle< BlackVolTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_BlackVolTermStructure_Sg__asObservable(Handle< BlackVolTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_BlackVolTermStructure_Sg__reset(RelinkableHandle< BlackVolTermStructure > *self){
            self->linkTo(ext::shared_ptr<BlackVolTermStructure>());
        }
SWIGINTERN bool Handle_Sl_LocalVolTermStructure_Sg____nonzero__(Handle< LocalVolTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_LocalVolTermStructure_Sg____bool__(Handle< LocalVolTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_LocalVolTermStructure_Sg__asObservable(Handle< LocalVolTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_LocalVolTermStructure_Sg__reset(RelinkableHandle< LocalVolTermStructure > *self){
            self->linkTo(ext::shared_ptr<LocalVolTermStructure>());
        }
SWIGINTERN bool Handle_Sl_OptionletVolatilityStructure_Sg____nonzero__(Handle< OptionletVolatilityStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_OptionletVolatilityStructure_Sg____bool__(Handle< OptionletVolatilityStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_OptionletVolatilityStructure_Sg__asObservable(Handle< OptionletVolatilityStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_OptionletVolatilityStructure_Sg__reset(RelinkableHandle< OptionletVolatilityStructure > *self){
            self->linkTo(ext::shared_ptr<OptionletVolatilityStructure>());
        }
SWIGINTERN bool Handle_Sl_YoYOptionletVolatilitySurface_Sg____nonzero__(Handle< YoYOptionletVolatilitySurface > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_YoYOptionletVolatilitySurface_Sg____bool__(Handle< YoYOptionletVolatilitySurface > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_YoYOptionletVolatilitySurface_Sg__asObservable(Handle< YoYOptionletVolatilitySurface > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_YoYOptionletVolatilitySurface_Sg__reset(RelinkableHandle< YoYOptionletVolatilitySurface > *self){
            self->linkTo(ext::shared_ptr<YoYOptionletVolatilitySurface>());
        }

using QuantLib::SmileSection;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< SmileSection >, std::allocator< ext::shared_ptr< SmileSection > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< SmileSection >" "," "std::allocator< ext::shared_ptr< SmileSection > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__iterator(std::vector< ext::shared_ptr< SmileSection > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< SmileSection > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____bool__(std::vector< ext::shared_ptr< SmileSection > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::size_type std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____len__(std::vector< ext::shared_ptr< SmileSection > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____getslice__(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i,std::vector< ext::shared_ptr< SmileSection > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i,std::vector< ext::shared_ptr< SmileSection > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i,std::vector< ext::shared_ptr< SmileSection > >::difference_type j,std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____delslice__(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i,std::vector< ext::shared_ptr< SmileSection > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< SmileSection > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< SmileSection > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type id = i;
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< SmileSection > > const *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::difference_type i,std::vector< ext::shared_ptr< SmileSection > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::value_type std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__pop(std::vector< ext::shared_ptr< SmileSection > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__append(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::iterator std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::iterator std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::iterator first,std::vector< ext::shared_ptr< SmileSection > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< SmileSection > >::iterator std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::iterator pos,std::vector< ext::shared_ptr< SmileSection > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< SmileSection > > *self,std::vector< ext::shared_ptr< SmileSection > >::iterator pos,std::vector< ext::shared_ptr< SmileSection > >::size_type n,std::vector< ext::shared_ptr< SmileSection > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::SwaptionVolatilityStructure;

SWIGINTERN bool Handle_Sl_SwaptionVolatilityStructure_Sg____nonzero__(Handle< SwaptionVolatilityStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_SwaptionVolatilityStructure_Sg____bool__(Handle< SwaptionVolatilityStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_SwaptionVolatilityStructure_Sg__asObservable(Handle< SwaptionVolatilityStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_SwaptionVolatilityStructure_Sg__reset(RelinkableHandle< SwaptionVolatilityStructure > *self){
            self->linkTo(ext::shared_ptr<SwaptionVolatilityStructure>());
        }

using QuantLib::BlackConstantVol;


using QuantLib::BlackVarianceCurve;


using QuantLib::BlackVarianceSurface;

SWIGINTERN BlackVarianceSurface *new_BlackVarianceSurface(Date const &referenceDate,Calendar const &cal,std::vector< Date,std::allocator< Date > > const &dates,std::vector< Real,std::allocator< Real > > const &strikes,Matrix const &blackVols,DayCounter const &dayCounter,BlackVarianceSurface::Extrapolation lower=BlackVarianceSurface::InterpolatorDefaultExtrapolation,BlackVarianceSurface::Extrapolation upper=BlackVarianceSurface::InterpolatorDefaultExtrapolation,std::string const &interpolator=""){
            BlackVarianceSurface* surface =
                new BlackVarianceSurface(referenceDate,cal,
                                         dates,strikes,
                                         blackVols,dayCounter,lower,upper);
            std::string s = boost::to_lower_copy(interpolator);
            if (s == "" || s == "bilinear") {
                surface->setInterpolation<QuantLib::Bilinear>();
            } else if (s == "bicubic") {
                surface->setInterpolation<QuantLib::Bicubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
            return surface;
        }
SWIGINTERN void BlackVarianceSurface_setInterpolation__SWIG_0(BlackVarianceSurface *self,std::string const &interpolator=""){
            std::string s = boost::to_lower_copy(interpolator);
            if (s == "" || s == "bilinear") {
                self->setInterpolation<QuantLib::Bilinear>();
            } else if (s == "bicubic") {
                self->setInterpolation<QuantLib::Bicubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
        }

using QuantLib::ConstantOptionletVolatility;


using QuantLib::ConstantSwaptionVolatility;


using QuantLib::SwaptionVolatilityMatrix;
using QuantLib::SwaptionVolatilityDiscrete;

SWIGINTERN SwaptionVolatilityMatrix *new_SwaptionVolatilityMatrix__SWIG_12(Date const &referenceDate,std::vector< Date,std::allocator< Date > > const &dates,std::vector< Period,std::allocator< Period > > const &lengths,Matrix const &vols,DayCounter const &dayCounter,bool const flatExtrapolation=false,VolatilityType const type=ShiftedLognormal,Matrix const &shifts=Matrix()){
            return new SwaptionVolatilityMatrix(referenceDate, QuantLib::NullCalendar(), Following,
                                                dates, lengths, vols, dayCounter,
                                                flatExtrapolation, type, shifts);
        }
SWIGINTERN std::pair< unsigned int,unsigned int > SwaptionVolatilityMatrix_locate__SWIG_0(SwaptionVolatilityMatrix const *self,Date const &optionDate,Period const &swapTenor){
            auto sizes = self->locate(optionDate, swapTenor);
            return { (unsigned int)sizes.first, (unsigned int)sizes.second };
        }
SWIGINTERN std::pair< unsigned int,unsigned int > SwaptionVolatilityMatrix_locate__SWIG_1(SwaptionVolatilityMatrix const *self,Time optionTime,Time swapLength){
            auto sizes = self->locate(optionTime, swapLength);
            return { (unsigned int)sizes.first, (unsigned int)sizes.second };
        }

using QuantLib::SabrSmileSection;


using QuantLib::SviSmileSection;


using QuantLib::SviInterpolatedSmileSection;


using QuantLib::SwaptionVolatilityCube;
using QuantLib::SabrSwaptionVolatilityCube;
using QuantLib::InterpolatedSwaptionVolatilityCube;

SWIGINTERN ext::shared_ptr< SabrSmileSection > SabrSwaptionVolatilityCube_smileSection__SWIG_0(SabrSwaptionVolatilityCube const *self,Time optionTime,Time swapLength,bool extr=false){
            auto base = dynamic_cast<const SwaptionVolatilityStructure*>(self);
            return ext::dynamic_pointer_cast<SabrSmileSection>(base->smileSection(optionTime, swapLength, extr));
        }
SWIGINTERN ext::shared_ptr< SabrSmileSection > SabrSwaptionVolatilityCube_smileSection__SWIG_2(SabrSwaptionVolatilityCube const *self,Period const &optionTenor,Period const &swapTenor,bool extr=false){
            auto base = dynamic_cast<const SwaptionVolatilityStructure*>(self);
            return ext::dynamic_pointer_cast<SabrSmileSection>(base->smileSection(optionTenor, swapTenor, extr));
        }

using QuantLib::ConstantYoYOptionletVolatility;


using QuantLib::FlatSmileSection;


using QuantLib::InterpolatedSmileSection;
using QuantLib::Actual365Fixed;


using QuantLib::KahaleSmileSection;


using QuantLib::ZabrShortMaturityLognormal;
using QuantLib::ZabrShortMaturityNormal;
using QuantLib::ZabrLocalVolatility;
using QuantLib::ZabrFullFd;
using QuantLib::ZabrSmileSection;
using QuantLib::ZabrInterpolatedSmileSection;
using QuantLib::NoArbSabrSmileSection;
using QuantLib::NoArbSabrInterpolatedSmileSection;
using QuantLib::Option;


using QuantLib::sabrVolatility;
using QuantLib::shiftedSabrVolatility;
using QuantLib::sabrFlochKennedyVolatility;


using QuantLib::AndreasenHugeVolatilityInterpl;
using QuantLib::AndreasenHugeVolatilityAdapter;
using QuantLib::AndreasenHugeLocalVolAdapter;
using QuantLib::HestonBlackVolSurface;

SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__first(ext::tuple< Real,Real,Real > const *self){
        return ext::get<0>(*self);
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__second(ext::tuple< Real,Real,Real > const *self){
        return ext::get<1>(*self);
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__third(ext::tuple< Real,Real,Real > const *self){
        return ext::get<2>(*self);
      }

using QuantLib::CmsMarket;


using QuantLib::CmsMarketCalibration;


using QuantLib::CashFlow;
using QuantLib::Leg;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< CashFlow >, std::allocator< ext::shared_ptr< CashFlow > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< CashFlow >" "," "std::allocator< ext::shared_ptr< CashFlow > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__iterator(std::vector< ext::shared_ptr< CashFlow > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< CashFlow > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____bool__(std::vector< ext::shared_ptr< CashFlow > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::size_type std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____len__(std::vector< ext::shared_ptr< CashFlow > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____getslice__(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i,std::vector< ext::shared_ptr< CashFlow > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i,std::vector< ext::shared_ptr< CashFlow > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i,std::vector< ext::shared_ptr< CashFlow > >::difference_type j,std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____delslice__(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i,std::vector< ext::shared_ptr< CashFlow > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< CashFlow > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< CashFlow > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< CashFlow > > const *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::difference_type i,std::vector< ext::shared_ptr< CashFlow > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::value_type std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__pop(std::vector< ext::shared_ptr< CashFlow > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__append(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::iterator first,std::vector< ext::shared_ptr< CashFlow > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< CashFlow > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::iterator pos,std::vector< ext::shared_ptr< CashFlow > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< CashFlow > > *self,std::vector< ext::shared_ptr< CashFlow > >::iterator pos,std::vector< ext::shared_ptr< CashFlow > >::size_type n,std::vector< ext::shared_ptr< CashFlow > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >, std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >" "," "std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Leg_Sg__iterator(std::vector< Leg > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Leg_Sg____nonzero__(std::vector< Leg > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Leg_Sg____bool__(std::vector< Leg > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type std_vector_Sl_Leg_Sg____len__(std::vector< Leg > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *std_vector_Sl_Leg_Sg____getslice__(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____setslice____SWIG_0(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >());
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____setslice____SWIG_1(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____delslice__(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____delitem____SWIG_0(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *std_vector_Sl_Leg_Sg____getitem____SWIG_0(std::vector< Leg > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____setitem____SWIG_0(std::vector< Leg > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____setitem____SWIG_1(std::vector< Leg > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____delitem____SWIG_1(std::vector< Leg > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type id = i;
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &std_vector_Sl_Leg_Sg____getitem____SWIG_1(std::vector< Leg > const *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Leg_Sg____setitem____SWIG_2(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type std_vector_Sl_Leg_Sg__pop(std::vector< Leg > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Leg_Sg__append(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator std_vector_Sl_Leg_Sg__erase__SWIG_0(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator std_vector_Sl_Leg_Sg__erase__SWIG_1(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator first,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator std_vector_Sl_Leg_Sg__insert__SWIG_0(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Leg_Sg__insert__SWIG_1(std::vector< Leg > *self,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::SimpleCashFlow;
using QuantLib::IndexedCashFlow;
using QuantLib::Redemption;
using QuantLib::AmortizingPayment;
using QuantLib::Coupon;
using QuantLib::FixedRateCoupon;
using QuantLib::FloatingRateCoupon;
using QuantLib::RateAveraging;
using QuantLib::OvernightIndexedCoupon;


    ext::shared_ptr<IndexedCashFlow> as_indexed_cashflow(const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<IndexedCashFlow>(cf);
    }


    ext::shared_ptr<Coupon> as_coupon(const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<Coupon>(cf);
    }


    ext::shared_ptr<FixedRateCoupon> as_fixed_rate_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<FixedRateCoupon>(cf);
    }


using QuantLib::FloatingRateCouponPricer;


    ext::shared_ptr<FloatingRateCoupon> as_floating_rate_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<FloatingRateCoupon>(cf);
    }


    ext::shared_ptr<OvernightIndexedCoupon> as_overnight_indexed_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<OvernightIndexedCoupon>(cf);
    }


using QuantLib::CappedFlooredCoupon;


using QuantLib::IborCoupon;
using QuantLib::CappedFlooredIborCoupon;
using QuantLib::SubPeriodsCoupon;

SWIGINTERN void IborCoupon_createAtParCoupons(){
            IborCoupon::Settings::instance().createAtParCoupons();
        }
SWIGINTERN void IborCoupon_createIndexedCoupons(){
            IborCoupon::Settings::instance().createIndexedCoupons();
        }
SWIGINTERN bool IborCoupon_usingAtParCoupons(){
            return IborCoupon::Settings::instance().usingAtParCoupons();
        }

    ext::shared_ptr<SubPeriodsCoupon> as_sub_periods_coupon(
      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<SubPeriodsCoupon>(cf);
    }


using QuantLib::IborCouponPricer;
using QuantLib::BlackIborCouponPricer;
using QuantLib::SubPeriodsPricer;
using QuantLib::CompoundingRatePricer;
using QuantLib::AveragingRatePricer;


using QuantLib::CmsCoupon;
using QuantLib::CappedFlooredCmsCoupon;
using QuantLib::CmsSpreadCoupon;
using QuantLib::CappedFlooredCmsSpreadCoupon;


using QuantLib::CmsCouponPricer;
using QuantLib::AnalyticHaganPricer;
using QuantLib::NumericHaganPricer;
using QuantLib::GFunctionFactory;
using QuantLib::LinearTsrPricer;
using QuantLib::CmsSpreadCouponPricer;
using QuantLib::LognormalCmsSpreadPricer;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< CmsCouponPricer >, std::allocator< ext::shared_ptr< CmsCouponPricer > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< CmsCouponPricer >" "," "std::allocator< ext::shared_ptr< CmsCouponPricer > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__iterator(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< CmsCouponPricer > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____bool__(std::vector< ext::shared_ptr< CmsCouponPricer > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____len__(std::vector< ext::shared_ptr< CmsCouponPricer > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____getslice__(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j,std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____delslice__(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > const *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__pop(std::vector< ext::shared_ptr< CmsCouponPricer > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__append(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator first,std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< CmsCouponPricer > > *self,std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos,std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::EquityCashFlow;
using QuantLib::EquityCashFlowPricer;
using QuantLib::EquityQuantoCashFlowPricer;


Leg _FixedRateLeg(const Schedule& schedule,
                  const DayCounter& dayCount,
                  const std::vector<Real>& nominals,
                  const std::vector<Rate>& couponRates,
                  BusinessDayConvention paymentAdjustment = Following,
                  const DayCounter& firstPeriodDayCount = DayCounter(),
                  const Period& exCouponPeriod = Period(),
                  const Calendar& exCouponCalendar = Calendar(),
                  BusinessDayConvention exCouponConvention = Unadjusted,
                  bool exCouponEndOfMonth = false,
                  const Calendar& paymentCalendar = Calendar(),
                  const Integer paymentLag = 0,
                  Compounding comp = Simple,
                  Frequency freq = Annual) {
    return QuantLib::FixedRateLeg(schedule)
        .withNotionals(nominals)
        .withCouponRates(couponRates, dayCount, comp, freq)
        .withPaymentAdjustment(paymentAdjustment)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withFirstPeriodDayCounter(firstPeriodDayCount)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth);
}


Leg _IborLeg(const std::vector<Real>& nominals,
             const Schedule& schedule,
             const ext::shared_ptr<IborIndex>& index,
             const DayCounter& paymentDayCounter = DayCounter(),
             const BusinessDayConvention paymentConvention = Following,
             const std::vector<Natural>& fixingDays = std::vector<Natural>(),
             const std::vector<Real>& gearings = std::vector<Real>(),
             const std::vector<Spread>& spreads = std::vector<Spread>(),
             const std::vector<Rate>& caps = std::vector<Rate>(),
             const std::vector<Rate>& floors = std::vector<Rate>(),
             bool isInArrears = false,
             const Period& exCouponPeriod = Period(),
             const Calendar& exCouponCalendar = Calendar(),
             BusinessDayConvention exCouponConvention = Unadjusted,
             bool exCouponEndOfMonth = false,
             const Calendar& paymentCalendar = Calendar(),
             const Integer paymentLag = 0,
             ext::optional<bool> withIndexedCoupons = ext::nullopt) {
    return QuantLib::IborLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth)
        .withIndexedCoupons(withIndexedCoupons);
}


Leg _OvernightLeg(const std::vector<Real>& nominals,
                  const Schedule& schedule,
                  const ext::shared_ptr<OvernightIndex>& index,
                  const DayCounter& paymentDayCounter = DayCounter(),
                  const BusinessDayConvention paymentConvention = Following,
                  const std::vector<Real>& gearings = std::vector<Real>(),
                  const std::vector<Spread>& spreads = std::vector<Spread>(),
                  bool telescopicValueDates = false,
                  RateAveraging::Type averagingMethod = RateAveraging::Compound,
                  const Calendar& paymentCalendar = Calendar(),
                  const Integer paymentLag = 0) {
    return QuantLib::OvernightLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withTelescopicValueDates(telescopicValueDates)
        .withAveragingMethod(averagingMethod);
}


Leg _CmsLeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const ext::shared_ptr<SwapIndex>& index,
            const DayCounter& paymentDayCounter = DayCounter(),
            const BusinessDayConvention paymentConvention = Following,
            const std::vector<Natural>& fixingDays = std::vector<Natural>(),
            const std::vector<Real>& gearings = std::vector<Real>(),
            const std::vector<Spread>& spreads = std::vector<Spread>(),
            const std::vector<Rate>& caps = std::vector<Rate>(),
            const std::vector<Rate>& floors = std::vector<Rate>(),
            bool isInArrears = false,
            const Period& exCouponPeriod = Period(),
            const Calendar& exCouponCalendar = Calendar(),
            const BusinessDayConvention exCouponConvention = Unadjusted,
            bool exCouponEndOfMonth = false) {
    return QuantLib::CmsLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withExCouponPeriod(exCouponPeriod, exCouponCalendar,
                            exCouponConvention, exCouponEndOfMonth)
        .inArrears(isInArrears);
}


Leg _CmsZeroLeg(const std::vector<Real>& nominals,
                const Schedule& schedule,
                const ext::shared_ptr<SwapIndex>& index,
                const DayCounter& paymentDayCounter = DayCounter(),
                const BusinessDayConvention paymentConvention = Following,
                const std::vector<Natural>& fixingDays = std::vector<Natural>(),
                const std::vector<Real>& gearings = std::vector<Real>(),
                const std::vector<Spread>& spreads = std::vector<Spread>(),
                const std::vector<Rate>& caps = std::vector<Rate>(),
                const std::vector<Rate>& floors = std::vector<Rate>(),
                const Period& exCouponPeriod = Period(),
                const Calendar& exCouponCalendar = Calendar(),
                const BusinessDayConvention exCouponConvention = Unadjusted,
                bool exCouponEndOfMonth = false) {
    return QuantLib::CmsLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withExCouponPeriod(exCouponPeriod, exCouponCalendar,
                            exCouponConvention, exCouponEndOfMonth)
        .withZeroPayments();
}


Leg _CmsSpreadLeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const ext::shared_ptr<SwapSpreadIndex>& index,
            const DayCounter& paymentDayCounter = DayCounter(),
            const BusinessDayConvention paymentConvention = Following,
            const std::vector<Natural>& fixingDays = std::vector<Natural>(),
            const std::vector<Real>& gearings = std::vector<Real>(),
            const std::vector<Spread>& spreads = std::vector<Spread>(),
            const std::vector<Rate>& caps = std::vector<Rate>(),
            const std::vector<Rate>& floors = std::vector<Rate>(),
            bool isInArrears = false) {
    return QuantLib::CmsSpreadLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .inArrears(isInArrears);
}


Leg _SubPeriodsLeg(const std::vector<Real>& nominals,
                   const Schedule& schedule,
                   const ext::shared_ptr<IborIndex>& index,
                   const DayCounter& paymentDayCounter = DayCounter(),
                   const BusinessDayConvention paymentConvention = Following,
                   const Calendar& paymentCalendar = Calendar(),
                   Integer paymentLag = 0,
                   const std::vector<Natural>& fixingDays = std::vector<Natural>(),
                   const std::vector<Real>& gearings = std::vector<Real>(),
                   const std::vector<Spread>& couponSpreads = std::vector<Spread>(),
                   const std::vector<Spread>& rateSpreads = std::vector<Spread>(),
                   const Period& exCouponPeriod = Period(),
                   const Calendar& exCouponCalendar = Calendar(),
                   BusinessDayConvention exCouponConvention = Unadjusted,
                   bool exCouponEndOfMonth = false,
                   RateAveraging::Type averagingMethod = RateAveraging::Compound) {
    return QuantLib::SubPeriodsLeg(schedule, index)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withPaymentLag(paymentLag)
        .withFixingDays(fixingDays)
        .withGearings(gearings)
        .withCouponSpreads(couponSpreads)
        .withRateSpreads(rateSpreads)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth)
        .withAveragingMethod(averagingMethod);
}


using QuantLib::CashFlows;
using QuantLib::Duration;

SWIGINTERN ext::shared_ptr< CashFlow > CashFlows_previousCashFlow__SWIG_0(Leg const &leg,bool includeSettlementDateFlows,Date settlementDate=Date()){
            Leg::const_reverse_iterator i =
                QuantLib::CashFlows::previousCashFlow(
                    leg, includeSettlementDateFlows, settlementDate);

            if (i == leg.rend())
                return ext::shared_ptr<CashFlow>();
            else
                return *i;
        }
SWIGINTERN ext::shared_ptr< CashFlow > CashFlows_nextCashFlow__SWIG_0(Leg const &leg,bool includeSettlementDateFlows,Date settlementDate=Date()){
            Leg::const_iterator i =
                QuantLib::CashFlows::nextCashFlow(
                    leg, includeSettlementDateFlows, settlementDate);

            if (i == leg.end())
                return ext::shared_ptr<CashFlow>();
            else
                return *i;
        }
SWIGINTERN Real CashFlows_npv__SWIG_0(Leg const &leg,ext::shared_ptr< YieldTermStructure > const &discountCurve,Spread zSpread,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npv(leg, discountCurve,
                                            zSpread,
                                            dayCounter,
                                            compounding,
                                            frequency,
                                            includeSettlementDateFlows,
                                            settlementDate,
                                            npvDate);
        }
SWIGINTERN Real CashFlows_npv__SWIG_3(Leg const &leg,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npv(leg, **discountCurve,
                                            includeSettlementDateFlows,
                                            settlementDate, npvDate);
        }
SWIGINTERN Real CashFlows_bps__SWIG_0(Leg const &leg,ext::shared_ptr< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::bps(leg, *discountCurve,
                                            includeSettlementDateFlows,
                                            settlementDate, npvDate);
        }
SWIGINTERN Real CashFlows_bps__SWIG_3(Leg const &leg,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::bps(leg, **discountCurve,
                                            includeSettlementDateFlows,
                                            settlementDate, npvDate);
        }
SWIGINTERN std::pair< Real,Real > CashFlows_npvbps__SWIG_0(Leg const &leg,ext::shared_ptr< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npvbps(leg, *discountCurve,
                                               includeSettlementDateFlows,
                                               settlementDate, npvDate);
        }
SWIGINTERN std::pair< Real,Real > CashFlows_npvbps__SWIG_3(Leg const &leg,Handle< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return QuantLib::CashFlows::npvbps(leg, **discountCurve,
                                               includeSettlementDateFlows,
                                               settlementDate, npvDate);
        }
SWIGINTERN Rate CashFlows_atmRate__SWIG_0(Leg const &leg,ext::shared_ptr< YieldTermStructure > const &discountCurve,bool includeSettlementDateFlows,Date const &settlementDate=Date(),Date const &npvDate=Date(),Real npv=Null< Real >()){
            return QuantLib::CashFlows::atmRate(leg, *discountCurve,
                                                includeSettlementDateFlows,
                                                settlementDate, npvDate,
                                                npv);
        }

using QuantLib::Dividend;


using QuantLib::FixedDividend;
using QuantLib::FractionalDividend;


using QuantLib::DividendSchedule;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< Dividend >, std::allocator< ext::shared_ptr< Dividend > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< Dividend >" "," "std::allocator< ext::shared_ptr< Dividend > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__iterator(std::vector< ext::shared_ptr< Dividend > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< Dividend > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____bool__(std::vector< ext::shared_ptr< Dividend > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::size_type std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____len__(std::vector< ext::shared_ptr< Dividend > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____getslice__(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i,std::vector< ext::shared_ptr< Dividend > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i,std::vector< ext::shared_ptr< Dividend > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i,std::vector< ext::shared_ptr< Dividend > >::difference_type j,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____delslice__(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i,std::vector< ext::shared_ptr< Dividend > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< Dividend > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< Dividend > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< Dividend > > const *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::difference_type i,std::vector< ext::shared_ptr< Dividend > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::value_type std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__pop(std::vector< ext::shared_ptr< Dividend > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__append(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::iterator first,std::vector< ext::shared_ptr< Dividend > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< Dividend > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::iterator pos,std::vector< ext::shared_ptr< Dividend > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< Dividend > > *self,std::vector< ext::shared_ptr< Dividend > >::iterator pos,std::vector< ext::shared_ptr< Dividend > >::size_type n,std::vector< ext::shared_ptr< Dividend > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Exercise;


using QuantLib::EuropeanExercise;
using QuantLib::AmericanExercise;
using QuantLib::BermudanExercise;
using QuantLib::RebatedExercise;
using QuantLib::SwingExercise;


using QuantLib::BusinessDayConvention;
using QuantLib::Calendar;
using QuantLib::Following;
using QuantLib::NullCalendar;


using QuantLib::TimeGrid;

SWIGINTERN TimeGrid *new_TimeGrid__SWIG_2(std::vector< Time,std::allocator< Time > > const &times){
            return new TimeGrid(times.begin(), times.end());
        }
SWIGINTERN TimeGrid *new_TimeGrid__SWIG_3(std::vector< Time,std::allocator< Time > > const &times,Size steps){
            return new TimeGrid(times.begin(), times.end(), steps);
        }
SWIGINTERN Time TimeGrid___getitem__(TimeGrid *self,Integer i){
            Integer size_ = static_cast<Integer>(self->size());
            if (i>=0 && i<size_) {
                return (*self)[i];
            } else if (i<0 && -i<=size_) {
                return (*self)[size_+i];
            } else {
                throw std::out_of_range("time-grid index out of range");
            }
        }
SWIGINTERN Time TimeGrid_dt(TimeGrid const *self,Integer i){
            Integer size_ = static_cast<Integer>(self->size());
            if (i>=0 && i<size_) {
                return self->dt(i);
            } else if (i<0 && -i<=size_) {
                return self->dt(size_+i);
            } else {
                throw std::out_of_range("time-grid index out of range");
            }
        }

using QuantLib::StochasticProcess;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< StochasticProcess >, std::allocator< ext::shared_ptr< StochasticProcess > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< StochasticProcess >" "," "std::allocator< ext::shared_ptr< StochasticProcess > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__iterator(std::vector< ext::shared_ptr< StochasticProcess > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< StochasticProcess > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____bool__(std::vector< ext::shared_ptr< StochasticProcess > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::size_type std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____len__(std::vector< ext::shared_ptr< StochasticProcess > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____getslice__(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j,std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____delslice__(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess > > const *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::value_type std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__pop(std::vector< ext::shared_ptr< StochasticProcess > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__append(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::iterator first,std::vector< ext::shared_ptr< StochasticProcess > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< StochasticProcess > > *self,std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos,std::vector< ext::shared_ptr< StochasticProcess > >::size_type n,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::StochasticProcess1D;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< StochasticProcess1D >, std::allocator< ext::shared_ptr< StochasticProcess1D > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< StochasticProcess1D >" "," "std::allocator< ext::shared_ptr< StochasticProcess1D > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__iterator(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< StochasticProcess1D > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____bool__(std::vector< ext::shared_ptr< StochasticProcess1D > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____len__(std::vector< ext::shared_ptr< StochasticProcess1D > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____getslice__(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j,std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____delslice__(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > const *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__pop(std::vector< ext::shared_ptr< StochasticProcess1D > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__append(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator first,std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< StochasticProcess1D > > *self,std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos,std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::GeneralizedBlackScholesProcess;


using QuantLib::BlackScholesProcess;


using QuantLib::BlackScholesMertonProcess;


using QuantLib::BlackProcess;


using QuantLib::GarmanKohlagenProcess;


using QuantLib::Merton76Process;


using QuantLib::StochasticProcessArray;


using QuantLib::GeometricBrownianMotionProcess;


using QuantLib::VarianceGammaProcess;


using QuantLib::HestonProcess;


using QuantLib::BatesProcess;


using QuantLib::HullWhiteProcess;


using QuantLib::HullWhiteForwardProcess;


using QuantLib::G2Process;


using QuantLib::G2ForwardProcess;


using QuantLib::GsrProcess;


    const ext::shared_ptr<GsrProcess> as_gsr_process(
                           const ext::shared_ptr<StochasticProcess>& proc) {
        return ext::dynamic_pointer_cast<GsrProcess>(proc);
    }


using QuantLib::OrnsteinUhlenbeckProcess;


using QuantLib::KlugeExtOUProcess;
using QuantLib::ExtendedOrnsteinUhlenbeckProcess;
using QuantLib::ExtOUWithJumpsProcess;

SWIGINTERN ExtendedOrnsteinUhlenbeckProcess *new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(Real speed,Volatility sigma,Real x0,PyObject *function,Real intEps=1e-4){
            
            const UnaryFunction f(function);
            return new ExtendedOrnsteinUhlenbeckProcess(
            	    speed, sigma, x0, f, 
            	    ExtendedOrnsteinUhlenbeckProcess::MidPoint, intEps);
        }

using QuantLib::GJRGARCHProcess;


using QuantLib::LazyObject;

SWIGINTERN void LazyObject_forwardFirstNotificationOnly(){
            LazyObject::Defaults::instance().forwardFirstNotificationOnly();
        }
SWIGINTERN void LazyObject_alwaysForwardNotifications(){
            LazyObject::Defaults::instance().alwaysForwardNotifications();
        }
SWIGINTERN bool LazyObject_forwardsAllNotifications(){
            return LazyObject::Defaults::instance().forwardsAllNotifications();
        }

using QuantLib::PricingEngine;


using QuantLib::Instrument;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< Instrument >, std::allocator< ext::shared_ptr< Instrument > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< Instrument >" "," "std::allocator< ext::shared_ptr< Instrument > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__iterator(std::vector< ext::shared_ptr< Instrument > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< Instrument > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____bool__(std::vector< ext::shared_ptr< Instrument > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::size_type std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____len__(std::vector< ext::shared_ptr< Instrument > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____getslice__(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i,std::vector< ext::shared_ptr< Instrument > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i,std::vector< ext::shared_ptr< Instrument > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i,std::vector< ext::shared_ptr< Instrument > >::difference_type j,std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____delslice__(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i,std::vector< ext::shared_ptr< Instrument > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< Instrument > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< Instrument > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< Instrument > > const *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::difference_type i,std::vector< ext::shared_ptr< Instrument > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::value_type std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__pop(std::vector< ext::shared_ptr< Instrument > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__append(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::iterator first,std::vector< ext::shared_ptr< Instrument > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< Instrument > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::iterator pos,std::vector< ext::shared_ptr< Instrument > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< Instrument > > *self,std::vector< ext::shared_ptr< Instrument > >::iterator pos,std::vector< ext::shared_ptr< Instrument > >::size_type n,std::vector< ext::shared_ptr< Instrument > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::Stock;


using QuantLib::CompositeInstrument;


using QuantLib::CalibrationHelper;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< CalibrationHelper >, std::allocator< ext::shared_ptr< CalibrationHelper > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< CalibrationHelper >" "," "std::allocator< ext::shared_ptr< CalibrationHelper > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__iterator(std::vector< ext::shared_ptr< CalibrationHelper > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< CalibrationHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____bool__(std::vector< ext::shared_ptr< CalibrationHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::size_type std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____len__(std::vector< ext::shared_ptr< CalibrationHelper > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____getslice__(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j,std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____delslice__(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< CalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< CalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< CalibrationHelper > > const *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::value_type std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__pop(std::vector< ext::shared_ptr< CalibrationHelper > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__append(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::iterator first,std::vector< ext::shared_ptr< CalibrationHelper > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< CalibrationHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< CalibrationHelper > > *self,std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos,std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::CalibratedModel;
using QuantLib::TermStructureConsistentModel;

SWIGINTERN bool Handle_Sl_CalibratedModel_Sg____nonzero__(Handle< CalibratedModel > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_CalibratedModel_Sg____bool__(Handle< CalibratedModel > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_CalibratedModel_Sg__asObservable(Handle< CalibratedModel > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_CalibratedModel_Sg__reset(RelinkableHandle< CalibratedModel > *self){
            self->linkTo(ext::shared_ptr<CalibratedModel>());
        }

using QuantLib::Parameter;
using QuantLib::ConstantParameter;
using QuantLib::NullParameter;
using QuantLib::PiecewiseConstantParameter;


#include <complex> 


using QuantLib::Payoff;


using QuantLib::Option;


using QuantLib::TypePayoff;
using QuantLib::FloatingTypePayoff;
using QuantLib::StrikedTypePayoff;


using QuantLib::DeltaVolQuote;

SWIGINTERN bool Handle_Sl_DeltaVolQuote_Sg____nonzero__(Handle< DeltaVolQuote > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_DeltaVolQuote_Sg____bool__(Handle< DeltaVolQuote > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_DeltaVolQuote_Sg__asObservable(Handle< DeltaVolQuote > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_DeltaVolQuote_Sg__reset(RelinkableHandle< DeltaVolQuote > *self){
            self->linkTo(ext::shared_ptr<DeltaVolQuote>());
        }

using QuantLib::OneAssetOption;
using QuantLib::VanillaOption;
using QuantLib::ForwardVanillaOption;

SWIGINTERN SampledCurve VanillaOption_priceCurve(VanillaOption *self){
            return self->result<SampledCurve>("priceCurve");
        }

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


      namespace swig {
	template <>  struct traits<std::pair< ext::shared_ptr< VanillaOption >, ext::shared_ptr< Quote > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "ext::shared_ptr< VanillaOption >" "," "ext::shared_ptr< Quote >" " >";
	  }
	};
      }
    

      namespace swig {
	template <>  struct traits<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >, std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >" "," "std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__iterator(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____nonzero__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____bool__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____len__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getslice__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delslice__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type id = i;
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type id = i;
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type id = i;
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type id = i;
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__pop(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__append(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator first,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *self,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::EuropeanOption;


using QuantLib::ForwardVanillaOption;


using QuantLib::QuantoVanillaOption;


using QuantLib::QuantoForwardVanillaOption;


using QuantLib::MultiAssetOption;


using QuantLib::AnalyticEuropeanEngine;


using QuantLib::HestonModel;

SWIGINTERN bool Handle_Sl_HestonModel_Sg____nonzero__(Handle< HestonModel > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_HestonModel_Sg____bool__(Handle< HestonModel > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_HestonModel_Sg__asObservable(Handle< HestonModel > *self){
        return ext::shared_ptr<Observable>(*self);
    }

using QuantLib::PiecewiseTimeDependentHestonModel;


using QuantLib::AnalyticHestonEngine;


SWIGINTERN int
SWIG_AsVal_std_complex_Sl_double_Sg_  (PyObject *o, std::complex<double>* val)
{
  if (PyComplex_Check(o)) {
    if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
    return SWIG_OK;
  } else {
    double d;    
    int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
    if (SWIG_IsOK(res)) {
      if (val) *val = std::complex<double>(d, 0.0);
      return res;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERNINLINE PyObject*
SWIG_From_std_complex_Sl_double_Sg_  (/*@SWIG:/opt/homebrew/Cellar/swig/4.1.1/share/swig/4.1.1/typemaps/swigmacros.swg,104,%ifcplusplus@*/

const std::complex<double>&



/*@SWIG@*/ c)
{
  return PyComplex_FromDoubles(std::real(c), std::imag(c));
}

SWIGINTERN AnalyticHestonEngine::OptimalAlpha *new_AnalyticHestonEngine_OptimalAlpha(Time const t,ext::shared_ptr< AnalyticHestonEngine > const &engine){
                    return new AnalyticHestonEngine::OptimalAlpha(t, engine.get());
            }

using QuantLib::COSHestonEngine;


using QuantLib::ExponentialFittingHestonEngine;


using QuantLib::AnalyticPTDHestonEngine;


using QuantLib::BatesModel;


using QuantLib::BatesEngine;


using QuantLib::IntegralEngine;


using QuantLib::BinomialVanillaEngine;
using QuantLib::CoxRossRubinstein;
using QuantLib::JarrowRudd;
using QuantLib::AdditiveEQPBinomialTree;
using QuantLib::Trigeorgis;
using QuantLib::Tian;
using QuantLib::LeisenReimer;
using QuantLib::Joshi4;


using QuantLib::MCEuropeanEngine;
using QuantLib::MCEuropeanHestonEngine;
using QuantLib::MCAmericanEngine;
using QuantLib::MCDigitalEngine;
using QuantLib::PseudoRandom;
using QuantLib::LowDiscrepancy;
using QuantLib::LsmBasisSystem;

SWIGINTERN MCEuropeanEngine< PseudoRandom > *new_MCEuropeanEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanEngine<PseudoRandom>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }
SWIGINTERN MCEuropeanEngine< LowDiscrepancy > *new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanEngine<LowDiscrepancy>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }
SWIGINTERN MCAmericanEngine< PseudoRandom > *new_MCAmericanEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial,int nCalibrationSamples=2048,ext::optional< bool > antitheticVariateCalibration=ext::nullopt,BigNatural seedCalibration=Null< Size >()){
            return new MCAmericanEngine<PseudoRandom>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             antitheticVariate,
                                             controlVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed,
                                             polynomOrder,
                                             polynomType,
                                             nCalibrationSamples,
                                             antitheticVariateCalibration,
                                             seedCalibration);
        }
SWIGINTERN MCAmericanEngine< LowDiscrepancy > *new_MCAmericanEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial,int nCalibrationSamples=2048,ext::optional< bool > antitheticVariateCalibration=ext::nullopt,BigNatural seedCalibration=Null< Size >()){
            return new MCAmericanEngine<LowDiscrepancy>(process,
                                             timeSteps,
                                             timeStepsPerYear,
                                             antitheticVariate,
                                             controlVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed,
                                             polynomOrder,
                                             polynomType,
                                             nCalibrationSamples,
                                             antitheticVariateCalibration,
                                             seedCalibration);
        }
SWIGINTERN MCEuropeanHestonEngine< PseudoRandom > *new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanHestonEngine<PseudoRandom>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCEuropeanHestonEngine< LowDiscrepancy > *new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanHestonEngine<LowDiscrepancy>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCDigitalEngine< PseudoRandom > *new_MCDigitalEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCDigitalEngine<PseudoRandom>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }
SWIGINTERN MCDigitalEngine< LowDiscrepancy > *new_MCDigitalEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCDigitalEngine<LowDiscrepancy>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }

using QuantLib::BaroneAdesiWhaleyApproximationEngine;


using QuantLib::BjerksundStenslandApproximationEngine;


using QuantLib::JuQuadraticApproximationEngine;


using QuantLib::AnalyticDigitalAmericanEngine;


using QuantLib::AnalyticDigitalAmericanKOEngine;


using QuantLib::DividendVanillaOption;


using QuantLib::AnalyticDividendEuropeanEngine;


using QuantLib::QdPlusAmericanEngine;


using QuantLib::QdFpLegendreScheme;
using QuantLib::QdFpIterationScheme;
using QuantLib::QdFpLegendreTanhSinhScheme;
using QuantLib::QdFpTanhSinhIterationScheme;
using QuantLib::QdFpAmericanEngine;


using QuantLib::FdmSchemeDesc;


using QuantLib::FdmQuantoHelper;


using QuantLib::LocalVolTermStructure;
using QuantLib::FdBlackScholesVanillaEngine;
using QuantLib::FdBlackScholesShoutEngine;
using QuantLib::FdOrnsteinUhlenbeckVanillaEngine;
using QuantLib::FdBatesVanillaEngine;
using QuantLib::FdHestonVanillaEngine;

SWIGINTERN ext::shared_ptr< FdBlackScholesVanillaEngine > FdBlackScholesVanillaEngine_make(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,DividendSchedule const &dividends={},ext::shared_ptr< FdmQuantoHelper > const &quantoHelper={},Size tGrid=100,Size xGrid=100,Size dampingSteps=0,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Douglas(),bool localVol=false,Real illegalLocalVolOverwrite=-Null< Real >(),FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=FdBlackScholesVanillaEngine::Spot){
            if (dividends.empty()) {
                return ext::make_shared<FdBlackScholesVanillaEngine>(
                                                process, quantoHelper, tGrid, xGrid,
                                                dampingSteps, schemeDesc,
                                                localVol, illegalLocalVolOverwrite,
                                                cashDividendModel);
            } else {
                return ext::make_shared<FdBlackScholesVanillaEngine>(
                                                process, dividends, quantoHelper, tGrid, xGrid,
                                                dampingSteps, schemeDesc,
                                                localVol, illegalLocalVolOverwrite,
                                                cashDividendModel);
            }
        }
SWIGINTERN ext::shared_ptr< FdHestonVanillaEngine > FdHestonVanillaEngine_make(ext::shared_ptr< HestonModel > const &model,DividendSchedule const &dividends={},ext::shared_ptr< FdmQuantoHelper > const &quantoHelper={},Size tGrid=100,Size xGrid=100,Size vGrid=50,Size dampingSteps=0,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer(),ext::shared_ptr< LocalVolTermStructure > const &leverageFct={},Real const mixingFactor=1.0){
            if (dividends.empty()) {
                return ext::make_shared<FdHestonVanillaEngine>(
                    model, quantoHelper, tGrid, xGrid, vGrid,
                    dampingSteps, schemeDesc, leverageFct, mixingFactor);
            } else {
                return ext::make_shared<FdHestonVanillaEngine>(
                    model, dividends, quantoHelper, tGrid, xGrid, vGrid,
                    dampingSteps, schemeDesc, leverageFct, mixingFactor);
            }
        }

using QuantLib::AnalyticCEVEngine;
using QuantLib::FdCEVVanillaEngine;


using QuantLib::FdSabrVanillaEngine;


using QuantLib::FdHestonHullWhiteVanillaEngine;


using QuantLib::AnalyticHestonHullWhiteEngine;


using QuantLib::AnalyticH1HWEngine;


using QuantLib::ForwardVanillaEngine;
using QuantLib::QuantoEngine;
typedef ForwardVanillaEngine<AnalyticEuropeanEngine> ForwardEuropeanEngine;
typedef QuantoEngine<VanillaOption,AnalyticEuropeanEngine> QuantoEuropeanEngine;
typedef QuantoEngine<ForwardVanillaOption,AnalyticEuropeanEngine> QuantoForwardEuropeanEngine;


using QuantLib::AnalyticHestonForwardEuropeanEngine;
using QuantLib::MCForwardEuropeanBSEngine;
using QuantLib::MCForwardEuropeanHestonEngine;

SWIGINTERN MCForwardEuropeanBSEngine< PseudoRandom > *new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCForwardEuropeanBSEngine<PseudoRandom>(process,
                                                      timeSteps,
                                                      timeStepsPerYear,
                                                      brownianBridge,
                                                      antitheticVariate,
                                                      requiredSamples,
                                                      requiredTolerance,
                                                      maxSamples,
                                                      seed);
        }
SWIGINTERN MCForwardEuropeanBSEngine< LowDiscrepancy > *new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCForwardEuropeanBSEngine<LowDiscrepancy>(process,
                                                      timeSteps,
                                                      timeStepsPerYear,
                                                      brownianBridge,
                                                      antitheticVariate,
                                                      requiredSamples,
                                                      requiredTolerance,
                                                      maxSamples,
                                                      seed);
        }
SWIGINTERN MCForwardEuropeanHestonEngine< PseudoRandom > *new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,bool controlVariate=false){
            return new MCForwardEuropeanHestonEngine<PseudoRandom>(process,
                                                          timeSteps,
                                                          timeStepsPerYear,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed,
                                                          controlVariate);
        }
SWIGINTERN MCForwardEuropeanHestonEngine< LowDiscrepancy > *new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< HestonProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,bool controlVariate=false){
            return new MCForwardEuropeanHestonEngine<LowDiscrepancy>(process,
                                                          timeSteps,
                                                          timeStepsPerYear,
                                                          antitheticVariate,
                                                          requiredSamples,
                                                          requiredTolerance,
                                                          maxSamples,
                                                          seed,
                                                          controlVariate);
        }

using QuantLib::BlackCalculator;


using QuantLib::VarianceGammaEngine;


using QuantLib::FFTVarianceGammaEngine;


using QuantLib::GJRGARCHModel;


using QuantLib::AnalyticGJRGARCHEngine;


using QuantLib::MCEuropeanGJRGARCHEngine;

SWIGINTERN MCEuropeanGJRGARCHEngine< PseudoRandom > *new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GJRGARCHProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanGJRGARCHEngine<PseudoRandom>(process,
                                                     timeSteps,
                                                     timeStepsPerYear,
                                                     antitheticVariate,
                                                     requiredSamples,
                                                     requiredTolerance,
                                                     maxSamples,
                                                     seed);
        }
SWIGINTERN MCEuropeanGJRGARCHEngine< LowDiscrepancy > *new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GJRGARCHProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            QL_REQUIRE(Size(timeSteps) != Null<Size>() ||
                       Size(timeStepsPerYear) != Null<Size>(),
                       "number of steps not specified");
            return new MCEuropeanGJRGARCHEngine<LowDiscrepancy>(process,
                                                     timeSteps,
                                                     timeStepsPerYear,
                                                     antitheticVariate,
                                                     requiredSamples,
                                                     requiredTolerance,
                                                     maxSamples,
                                                     seed);
        }

using QuantLib::MargrabeOption;
using QuantLib::AnalyticEuropeanMargrabeEngine;
using QuantLib::AnalyticAmericanMargrabeEngine;


using QuantLib::CompoundOption;
using QuantLib::AnalyticCompoundOptionEngine;


using QuantLib::SimpleChooserOption;
using QuantLib::AnalyticSimpleChooserEngine;


using QuantLib::ComplexChooserOption;
using QuantLib::AnalyticComplexChooserEngine;


using QuantLib::Average;
using QuantLib::ContinuousAveragingAsianOption;
using QuantLib::DiscreteAveragingAsianOption;

SWIGINTERN TimeGrid DiscreteAveragingAsianOption_timeGrid(DiscreteAveragingAsianOption *self){
            return self->result<TimeGrid>("TimeGrid");
        }

using QuantLib::AnalyticContinuousGeometricAveragePriceAsianEngine;
using QuantLib::AnalyticContinuousGeometricAveragePriceAsianHestonEngine;
using QuantLib::AnalyticDiscreteGeometricAveragePriceAsianEngine;
using QuantLib::AnalyticDiscreteGeometricAveragePriceAsianHestonEngine;
using QuantLib::AnalyticDiscreteGeometricAverageStrikeAsianEngine;


using QuantLib::MCDiscreteArithmeticAPEngine;
using QuantLib::MCDiscreteArithmeticAPHestonEngine;
using QuantLib::MCDiscreteArithmeticASEngine;
using QuantLib::MCDiscreteGeometricAPEngine;
using QuantLib::MCDiscreteGeometricAPHestonEngine;

SWIGINTERN MCDiscreteArithmeticAPEngine< PseudoRandom > *new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticAPEngine<PseudoRandom>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         controlVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteArithmeticAPEngine< LowDiscrepancy > *new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,bool controlVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticAPEngine<LowDiscrepancy>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         controlVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool controlVariate=false){
            return new MCDiscreteArithmeticAPHestonEngine<PseudoRandom>(process,
                                                               antitheticVariate,
                                                               requiredSamples,
                                                               requiredTolerance,
                                                               maxSamples,
                                                               seed,
                                                               timeSteps,
                                                               timeStepsPerYear,
                                                               controlVariate);
        }
SWIGINTERN MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool controlVariate=false){
            return new MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy>(process,
                                                               antitheticVariate,
                                                               requiredSamples,
                                                               requiredTolerance,
                                                               maxSamples,
                                                               seed,
                                                               timeSteps,
                                                               timeStepsPerYear,
                                                               controlVariate);
        }
SWIGINTERN MCDiscreteArithmeticASEngine< PseudoRandom > *new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticASEngine<PseudoRandom>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteArithmeticASEngine< LowDiscrepancy > *new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteArithmeticASEngine<LowDiscrepancy>(process,
                                                         brownianBridge,
                                                         antitheticVariate,
                                                         requiredSamples,
                                                         requiredTolerance,
                                                         maxSamples,
                                                         seed);
        }
SWIGINTERN MCDiscreteGeometricAPEngine< PseudoRandom > *new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteGeometricAPEngine<PseudoRandom>(process,
                                                        brownianBridge,
                                                        antitheticVariate,
                                                        requiredSamples,
                                                        requiredTolerance,
                                                        maxSamples,
                                                        seed);
        }
SWIGINTERN MCDiscreteGeometricAPEngine< LowDiscrepancy > *new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCDiscreteGeometricAPEngine<LowDiscrepancy>(process,
                                                        brownianBridge,
                                                        antitheticVariate,
                                                        requiredSamples,
                                                        requiredTolerance,
                                                        maxSamples,
                                                        seed);
        }
SWIGINTERN MCDiscreteGeometricAPHestonEngine< PseudoRandom > *new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >()){
            return new MCDiscreteGeometricAPHestonEngine<PseudoRandom>(process,
                                                              antitheticVariate,
                                                              requiredSamples,
                                                              requiredTolerance,
                                                              maxSamples,
                                                              seed,
                                                              timeSteps,
                                                              timeStepsPerYear);
        }
SWIGINTERN MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< HestonProcess > const &process,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >()){
            return new MCDiscreteGeometricAPHestonEngine<LowDiscrepancy>(process,
                                                              antitheticVariate,
                                                              requiredSamples,
                                                              requiredTolerance,
                                                              maxSamples,
                                                              seed,
                                                              timeSteps,
                                                              timeStepsPerYear);
        }

using QuantLib::ContinuousArithmeticAsianLevyEngine;


using QuantLib::FdBlackScholesAsianEngine;


using QuantLib::TurnbullWakemanAsianEngine;


using QuantLib::Barrier;


using QuantLib::BarrierOption;
using QuantLib::DividendBarrierOption;
using QuantLib::QuantoBarrierOption;


using QuantLib::PartialBarrier;


using QuantLib::PartialTimeBarrierOption;


using QuantLib::AnalyticPartialTimeBarrierOptionEngine;


using QuantLib::AnalyticBarrierEngine;
using QuantLib::MCBarrierEngine;

SWIGINTERN MCBarrierEngine< PseudoRandom > *new_MCBarrierEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),bool isBiased=false,BigInteger seed=0){
            return new MCBarrierEngine<PseudoRandom>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            isBiased,
                                            seed);
        }
SWIGINTERN MCBarrierEngine< LowDiscrepancy > *new_MCBarrierEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),bool isBiased=false,BigInteger seed=0){
            return new MCBarrierEngine<LowDiscrepancy>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            isBiased,
                                            seed);
        }

using QuantLib::QuantoEngine;
typedef QuantoEngine<BarrierOption,AnalyticBarrierEngine> QuantoBarrierEngine;


using QuantLib::FdBlackScholesBarrierEngine;
using QuantLib::FdBlackScholesRebateEngine;
using QuantLib::FdHestonBarrierEngine;
using QuantLib::FdHestonRebateEngine;


using QuantLib::AnalyticBinaryBarrierEngine;


using QuantLib::BinomialBarrierEngine;
using QuantLib::DiscretizedDermanKaniBarrierOption;


using QuantLib::VannaVolgaBarrierEngine;


using QuantLib::DoubleBarrierOption;
using QuantLib::DoubleBarrier;


using QuantLib::QuantoDoubleBarrierOption;


using QuantLib::AnalyticDoubleBarrierEngine;


using QuantLib::FdHestonDoubleBarrierEngine;


using QuantLib::SuoWangDoubleBarrierEngine;


using QuantLib::VannaVolgaDoubleBarrierEngine;


using QuantLib::AnalyticDoubleBarrierBinaryEngine;


using QuantLib::BinomialDoubleBarrierEngine;
using QuantLib::DiscretizedDermanKaniDoubleBarrierOption;


using QuantLib::PlainVanillaPayoff;
using QuantLib::PercentageStrikePayoff;
using QuantLib::CashOrNothingPayoff;
using QuantLib::AssetOrNothingPayoff;
using QuantLib::SuperSharePayoff;
using QuantLib::GapPayoff;
using QuantLib::VanillaForwardPayoff;


    const ext::shared_ptr<PlainVanillaPayoff> as_plain_vanilla_payoff(
                           const ext::shared_ptr<Payoff>& payoff) {
        return ext::dynamic_pointer_cast<PlainVanillaPayoff>(payoff);
    }


using QuantLib::BasketOption;
using QuantLib::BasketPayoff;
using QuantLib::MinBasketPayoff;
using QuantLib::MaxBasketPayoff;
using QuantLib::AverageBasketPayoff;
using QuantLib::SpreadBasketPayoff;


using QuantLib::MCEuropeanBasketEngine;
using QuantLib::MCAmericanBasketEngine;

SWIGINTERN MCEuropeanBasketEngine< PseudoRandom > *new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCEuropeanBasketEngine<PseudoRandom>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCEuropeanBasketEngine< LowDiscrepancy > *new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCEuropeanBasketEngine<LowDiscrepancy>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed);
        }
SWIGINTERN MCAmericanBasketEngine< PseudoRandom > *new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,Size nCalibrationSamples=Null< Size >(),Size polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial){
            return new MCAmericanBasketEngine<PseudoRandom>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed,
                                                   nCalibrationSamples,
                                                   polynomOrder,
                                                   polynomType);
        }
SWIGINTERN MCAmericanBasketEngine< LowDiscrepancy > *new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,intOrNull timeSteps=Null< Size >(),intOrNull timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0,Size nCalibrationSamples=Null< Size >(),Size polynomOrder=2,LsmBasisSystem::PolynomialType polynomType=LsmBasisSystem::Monomial){
            return new MCAmericanBasketEngine<LowDiscrepancy>(process,
                                                   timeSteps,
                                                   timeStepsPerYear,
                                                   brownianBridge,
                                                   antitheticVariate,
                                                   requiredSamples,
                                                   requiredTolerance,
                                                   maxSamples,
                                                   seed,
                                                   nCalibrationSamples,
                                                   polynomOrder,
                                                   polynomType);
        }

using QuantLib::StulzEngine;
using QuantLib::KirkEngine;
using QuantLib::Fd2dBlackScholesVanillaEngine;


using QuantLib::EverestOption;
using QuantLib::MCEverestEngine;

SWIGINTERN MCEverestEngine< PseudoRandom > *new_MCEverestEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,Size timeSteps=Null< Size >(),Size timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCEverestEngine<PseudoRandom>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }
SWIGINTERN MCEverestEngine< LowDiscrepancy > *new_MCEverestEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,Size timeSteps=Null< Size >(),Size timeStepsPerYear=Null< Size >(),bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCEverestEngine<LowDiscrepancy>(process,
                                            timeSteps,
                                            timeStepsPerYear,
                                            brownianBridge,
                                            antitheticVariate,
                                            requiredSamples,
                                            requiredTolerance,
                                            maxSamples,
                                            seed);
        }

using QuantLib::HimalayaOption;
using QuantLib::MCHimalayaEngine;

SWIGINTERN MCHimalayaEngine< PseudoRandom > *new_MCHimalayaEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCHimalayaEngine<PseudoRandom>(process,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }
SWIGINTERN MCHimalayaEngine< LowDiscrepancy > *new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< StochasticProcessArray > const &process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCHimalayaEngine<LowDiscrepancy>(process,
                                             brownianBridge,
                                             antitheticVariate,
                                             requiredSamples,
                                             requiredTolerance,
                                             maxSamples,
                                             seed);
        }

using QuantLib::blackFormula;
using QuantLib::blackFormulaImpliedStdDev;
using QuantLib::blackFormulaImpliedStdDevLiRS;
using QuantLib::blackFormulaCashItmProbability;
using QuantLib::blackFormulaAssetItmProbability;
using QuantLib::bachelierBlackFormula;
using QuantLib::bachelierBlackFormulaImpliedVol;
using QuantLib::bachelierBlackFormulaAssetItmProbability;


using QuantLib::BlackDeltaCalculator;


using QuantLib::TimeBasket;

SWIGINTERN Real TimeBasket___getitem__(TimeBasket *self,Date const &d){
            return (*self)[d];
        }
SWIGINTERN void TimeBasket___setitem__(TimeBasket *self,Date const &d,Real value){
            (*self)[d] = value;
        }
SWIGINTERN PyObject *TimeBasket_items(TimeBasket *self){
            PyObject* itemList = PyList_New(self->size());
            TimeBasket::iterator i;
            Size j;
            for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                Date* d = new Date(i->first);
                PyObject* item = PyTuple_New(2);
                PyTuple_SetItem(item,0,
                                SWIG_NewPointerObj((void *) d,
                                                   SWIGTYPE_p_Date,1));
                PyTuple_SetItem(item,1,PyFloat_FromDouble(i->second));
                PyList_SetItem(itemList,j,item);
            }
            return itemList;
        }
SWIGINTERN bool TimeBasket___contains__(TimeBasket *self,Date const &d){
            return self->hasDate(d);
        }
SWIGINTERN PyObject *TimeBasket___iter__(TimeBasket *self){
            #if PY_VERSION_HEX >= 0x02020000
            PyObject* keyList = PyList_New(self->size());
            TimeBasket::iterator i;
            Size j;
            for (i=self->begin(), j=0; i!=self->end(); ++i, ++j) {
                Date* d = new Date(i->first);
                PyList_SetItem(keyList,j,
                               SWIG_NewPointerObj((void *) d,
                                                  SWIGTYPE_p_Date,1));
            }
            PyObject* iter = PyObject_GetIter(keyList);
            Py_DECREF(keyList);
            return iter;
            #else
            throw std::runtime_error("Python 2.2 or later is needed"
                                     " for iterator support");
            #endif
            }

using QuantLib::Swap;
using QuantLib::VanillaSwap;
using QuantLib::MakeVanillaSwap;
using QuantLib::NonstandardSwap;
using QuantLib::DiscountingSwapEngine;
using QuantLib::FloatFloatSwap;
using QuantLib::OvernightIndexedSwap;
using QuantLib::MakeOIS;
using QuantLib::ZeroCouponSwap;
using QuantLib::EquityTotalReturnSwap;
using QuantLib::ArithmeticAverageOIS;
using QuantLib::simplifyNotificationGraph;

SWIGINTERN VanillaSwap *new_VanillaSwap__SWIG_0(Swap::Type type,Real nominal,Schedule const &fixedSchedule,Rate fixedRate,DayCounter const &fixedDayCount,Schedule const &floatSchedule,ext::shared_ptr< IborIndex > const &index,Spread spread,DayCounter const &floatingDayCount,ext::optional< bool > withIndexedCoupons=ext::nullopt){
            // work around the lack of typemap for this argument
            ext::optional<BusinessDayConvention> paymentConvention = ext::nullopt;

            return new VanillaSwap(type, nominal, fixedSchedule, fixedRate, fixedDayCount,
                                   floatSchedule, index, spread, floatingDayCount,
                                   paymentConvention, withIndexedCoupons);
        }
SWIGINTERN ext::shared_ptr< VanillaSwap > MakeVanillaSwap_makeVanillaSwap(MakeVanillaSwap *self){
                return (ext::shared_ptr<VanillaSwap>)(* self);
            }
SWIGINTERN DiscountingSwapEngine *new_DiscountingSwapEngine__SWIG_3(Handle< YieldTermStructure > const &discountCurve,Date const &settlementDate=Date(),Date const &npvDate=Date()){
            return new DiscountingSwapEngine(discountCurve,
                                             ext::nullopt,
                                             settlementDate,
                                             npvDate);
        }

using QuantLib::AssetSwap;
using QuantLib::OvernightIndexedSwapIndex;

SWIGINTERN ext::shared_ptr< OvernightIndexedSwap > MakeOIS_makeOIS(MakeOIS *self){
                return (ext::shared_ptr<OvernightIndexedSwap>)(* self);
            }

    ext::shared_ptr<OvernightIndexedSwap> as_overnight_swap_index(
                          const ext::shared_ptr<InterestRateIndex>& index) {
        return ext::dynamic_pointer_cast<OvernightIndexedSwap>(index);
    }


  using QuantLib::InflationTermStructure;
  using QuantLib::Seasonality;
  using QuantLib::MultiplicativePriceSeasonality;
  using QuantLib::KerkhofSeasonality;


  using QuantLib::InflationTermStructure;
  using QuantLib::YoYInflationTermStructure;
  using QuantLib::ZeroInflationTermStructure;

SWIGINTERN bool Handle_Sl_YoYInflationTermStructure_Sg____nonzero__(Handle< YoYInflationTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_YoYInflationTermStructure_Sg____bool__(Handle< YoYInflationTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_YoYInflationTermStructure_Sg__asObservable(Handle< YoYInflationTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_YoYInflationTermStructure_Sg__reset(RelinkableHandle< YoYInflationTermStructure > *self){
            self->linkTo(ext::shared_ptr<YoYInflationTermStructure>());
        }
SWIGINTERN bool Handle_Sl_ZeroInflationTermStructure_Sg____nonzero__(Handle< ZeroInflationTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_ZeroInflationTermStructure_Sg____bool__(Handle< ZeroInflationTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_ZeroInflationTermStructure_Sg__asObservable(Handle< ZeroInflationTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_ZeroInflationTermStructure_Sg__reset(RelinkableHandle< ZeroInflationTermStructure > *self){
            self->linkTo(ext::shared_ptr<ZeroInflationTermStructure>());
        }

using QuantLib::Region;
using QuantLib::CustomRegion;
using QuantLib::InflationIndex;
using QuantLib::ZeroInflationIndex;
using QuantLib::YoYInflationIndex;


    ext::shared_ptr<ZeroInflationIndex> as_zero_inflation_index(const ext::shared_ptr<Index>& i) {
        return ext::dynamic_pointer_cast<ZeroInflationIndex>(i);
    }


using QuantLib::EUHICP;


using QuantLib::EUHICPXT;


using QuantLib::FRHICP;


using QuantLib::UKRPI;


using QuantLib::USCPI;


using QuantLib::ZACPI;


using QuantLib::UKHICP;


using QuantLib::YYEUHICP;


using QuantLib::YYEUHICPXT;


using QuantLib::YYEUHICPr;


using QuantLib::YYFRHICP;


using QuantLib::YYFRHICPr;


using QuantLib::YYUKRPI;


using QuantLib::YYUKRPIr;


using QuantLib::YYUSCPI;


using QuantLib::YYUSCPIr;


using QuantLib::YYZACPI;


using QuantLib::YYZACPIr;


using QuantLib::AUCPI;


using QuantLib::CPI;


using QuantLib::InflationCoupon;
using QuantLib::CPICoupon;
using QuantLib::CPICouponPricer;
using QuantLib::CPICashFlow;
using QuantLib::ZeroInflationCashFlow;


    ext::shared_ptr<InflationCoupon> as_inflation_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<InflationCoupon>(cf);
    }


    ext::shared_ptr<CPICoupon> as_cpi_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<CPICoupon>(cf);
    }


    ext::shared_ptr<CPICashFlow> as_cpi_cashflow(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<CPICashFlow>(cf);
    }


Leg _CPILeg(const std::vector<Real>& nominals,
            const Schedule& schedule,
            const ext::shared_ptr<ZeroInflationIndex>& index,
            Real baseCPI,
            const Period& observationLag,
            const DayCounter& paymentDayCounter = DayCounter(),
            const BusinessDayConvention paymentConvention = Following,
            const std::vector<Real>& fixedRates = std::vector<Real>(),
            const std::vector<Spread>& spreads = std::vector<Spread>(),
            const std::vector<Rate>& caps = std::vector<Rate>(),
            const std::vector<Rate>& floors = std::vector<Rate>(),
            const Period& exCouponPeriod = Period(),
            const Calendar& exCouponCalendar = Calendar(),
            BusinessDayConvention exCouponConvention = Unadjusted,
            bool exCouponEndOfMonth = false,
            const Calendar& paymentCalendar = Calendar(),
            bool growthOnly = true,
            CPI::InterpolationType observationInterpolation = CPI::AsIndex) {
    return QuantLib::CPILeg(schedule, index, baseCPI, observationLag)
        .withNotionals(nominals)
        .withPaymentDayCounter(paymentDayCounter)
        .withPaymentAdjustment(paymentConvention)
        .withPaymentCalendar(paymentCalendar.empty() ? schedule.calendar() : paymentCalendar)
        .withFixedRates(fixedRates)
        .withSpreads(spreads)
        .withCaps(caps)
        .withFloors(floors)
        .withExCouponPeriod(exCouponPeriod,
                            exCouponCalendar,
                            exCouponConvention,
                            exCouponEndOfMonth)
        .withSubtractInflationNominal(growthOnly)
        .withObservationInterpolation(observationInterpolation);
}


    ext::shared_ptr<ZeroInflationCashFlow> as_zero_inflation_cash_flow(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<ZeroInflationCashFlow>(cf);
    }


using QuantLib::BootstrapHelper;
using QuantLib::ZeroCouponInflationSwapHelper;
using QuantLib::YearOnYearInflationSwapHelper;
using QuantLib::YoYOptionletHelper;


  namespace swig {
    template <>  struct traits< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > {
      typedef pointer_category category;
      static const char* type_name() { return"ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >, std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >" "," "std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__iterator(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____nonzero__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____bool__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____len__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____getslice__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____delslice__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__pop(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__append(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator first,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > {
      typedef pointer_category category;
      static const char* type_name() { return"ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >, std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >" "," "std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__iterator(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____nonzero__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____bool__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____len__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____getslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____delslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__pop(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__append(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator first,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > {
      typedef pointer_category category;
      static const char* type_name() { return"ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >, std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >" "," "std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__iterator(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____nonzero__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____bool__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____len__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____getslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____delslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__pop(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__append(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator first,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *self,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::PiecewiseZeroInflationCurve;
using QuantLib::PiecewiseYoYInflationCurve;


using QuantLib::inflationPeriod;
using QuantLib::inflationYearFraction;


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


    Date inflationBaseDate(const Date& referenceDate,
                           const Period& observationLag,
                           Frequency frequency,
                           bool indexIsInterpolated) {
        if (indexIsInterpolated) {
            return referenceDate - observationLag;
        } else {
            return QuantLib::inflationPeriod(referenceDate - observationLag,
                                             frequency).first;
        }
    }



using QuantLib::YoYInflationCoupon;
using QuantLib::CappedFlooredYoYInflationCoupon;
using QuantLib::YoYInflationCouponPricer;
using QuantLib::setCouponPricer;
using QuantLib::BlackYoYInflationCouponPricer;
using QuantLib::UnitDisplacedBlackYoYInflationCouponPricer;
using QuantLib::BachelierYoYInflationCouponPricer;


    ext::shared_ptr<YoYInflationCoupon> as_yoy_inflation_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<YoYInflationCoupon>(cf);
    }


    ext::shared_ptr<CappedFlooredYoYInflationCoupon> as_capped_floored_yoy_inflation_coupon(
                                      const ext::shared_ptr<CashFlow>& cf) {
        return ext::dynamic_pointer_cast<CappedFlooredYoYInflationCoupon>(cf);
    }


Leg _yoyInflationLeg(const Schedule& schedule,
                     const Calendar& calendar,
                     const ext::shared_ptr<YoYInflationIndex>& index,
                     const Period& observationLag,
                     const std::vector<Real>& notionals,
                     const DayCounter& paymentDayCounter,
                     BusinessDayConvention paymentAdjustment = Following,
                     Natural fixingDays = 0,
                     const std::vector<Real>& gearings = std::vector<Real>(),
                     const std::vector<Spread>& spreads = std::vector<Spread>(),
                     const std::vector<Rate>& caps = std::vector<Rate>(),
                     const std::vector<Rate>& floors = std::vector<Rate>()) {
        return QuantLib::yoyInflationLeg(schedule, calendar, index, observationLag)
            .withNotionals(notionals)
            .withPaymentDayCounter(paymentDayCounter)
            .withPaymentAdjustment(paymentAdjustment)
            .withFixingDays(fixingDays)
            .withGearings(gearings)
            .withSpreads(spreads)
            .withCaps(caps)
            .withFloors(floors);
}


using QuantLib::ZeroCouponInflationSwap;
using QuantLib::YearOnYearInflationSwap;
using QuantLib::CPISwap;


using QuantLib::YoYInflationCapFloor;
using QuantLib::YoYInflationCap;
using QuantLib::YoYInflationFloor;
using QuantLib::YoYInflationCollar;

SWIGINTERN std::vector< Real,std::allocator< Real > > YoYInflationCapFloor_optionletPrices(YoYInflationCapFloor *self){
             return self->result<std::vector<Real> >("optionletsPrice");
         }

using QuantLib::InterpolatedZeroInflationCurve;
using QuantLib::InterpolatedYoYInflationCurve;


using QuantLib::YoYCapFloorTermPriceSurface;
using QuantLib::InterpolatedYoYCapFloorTermPriceSurface;


typedef InterpolatedYoYCapFloorTermPriceSurface<Bicubic, Cubic> YoYInflationCapFloorTermPriceSurface;

SWIGINTERN YoYInflationCapFloorTermPriceSurface *new_YoYInflationCapFloorTermPriceSurface__SWIG_0(Natural fixingDays,Period const &yyLag,ext::shared_ptr< YoYInflationIndex > const &yii,Rate baseRate,Handle< YieldTermStructure > const &nominal,DayCounter const &dc,Calendar const &cal,BusinessDayConvention const &bdc,std::vector< Rate,std::allocator< Rate > > const &cStrikes,std::vector< Rate,std::allocator< Rate > > const &fStrikes,std::vector< Period,std::allocator< Period > > const &cfMaturities,Matrix const &cPrice,Matrix const &fPrice,Bicubic const &interpolator2d=Bicubic(),Cubic const &interpolator1d=Cubic()){
            return new YoYInflationCapFloorTermPriceSurface(fixingDays, yyLag, yii, baseRate, nominal,
                            dc, cal, bdc, cStrikes, fStrikes, cfMaturities,
                            cPrice, fPrice);
        }

using QuantLib::YoYInflationCapFloorEngine;
using QuantLib::YoYInflationBlackCapFloorEngine;
using QuantLib::YoYInflationUnitDisplacedBlackCapFloorEngine;
using QuantLib::YoYInflationBachelierCapFloorEngine;

SWIGINTERN YoYOptionletHelper *new_YoYOptionletHelper(Handle< Quote > const &price,Real notional,YoYInflationCapFloor::Type capFloorType,Period &lag,DayCounter const &yoyDayCounter,Calendar const &paymentCalendar,Natural fixingDays,ext::shared_ptr< YoYInflationIndex > const &index,Rate strike,Size n,ext::shared_ptr< PricingEngine > const &pricer){
            ext::shared_ptr<QuantLib::YoYInflationCapFloorEngine> engine = ext::dynamic_pointer_cast<YoYInflationCapFloorEngine>(pricer);
            return new YoYOptionletHelper(price, notional, capFloorType, lag, yoyDayCounter, paymentCalendar, fixingDays, index, strike, n, engine);
         }

using QuantLib::YoYOptionletStripper;
using QuantLib::InterpolatedYoYOptionletStripper;

SWIGINTERN void YoYOptionletStripper_initialize(YoYOptionletStripper const *self,ext::shared_ptr< YoYCapFloorTermPriceSurface > const &surf,ext::shared_ptr< PricingEngine > const &pricer,Real slope){
            ext::shared_ptr<QuantLib::YoYInflationCapFloorEngine> engine = ext::dynamic_pointer_cast<YoYInflationCapFloorEngine>(pricer);
            return (self)->initialize(surf, engine, slope);
        }

using QuantLib::InterpolatedYoYOptionletVolatilityCurve;
using QuantLib::KInterpolatedYoYOptionletVolatilitySurface;
using QuantLib::YoYInflationCapFloorEngine;

SWIGINTERN KInterpolatedYoYOptionletVolatilitySurface< Linear > *new_KInterpolatedYoYOptionletVolatilitySurface_Sl_Linear_Sg___SWIG_0(Natural settlementDays,Calendar const &calendar,BusinessDayConvention bdc,DayCounter const &dc,Period const &lag,ext::shared_ptr< YoYCapFloorTermPriceSurface > const &capFloorPrices,ext::shared_ptr< PricingEngine > const &pricer,ext::shared_ptr< YoYOptionletStripper > const &yoyOptionletStripper,Real slope,Linear const &interpolator=Linear()){
                 ext::shared_ptr<QuantLib::YoYInflationCapFloorEngine> engine = ext::dynamic_pointer_cast<YoYInflationCapFloorEngine>(pricer);
                     return new KInterpolatedYoYOptionletVolatilitySurface<Linear>(settlementDays,
                                 calendar, bdc, dc, lag, capFloorPrices, engine, yoyOptionletStripper,
                                 slope, interpolator);
        }

using QuantLib::ShortRateModel;

SWIGINTERN bool Handle_Sl_ShortRateModel_Sg____nonzero__(Handle< ShortRateModel > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_ShortRateModel_Sg____bool__(Handle< ShortRateModel > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_ShortRateModel_Sg__asObservable(Handle< ShortRateModel > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_ShortRateModel_Sg__reset(RelinkableHandle< ShortRateModel > *self){
            self->linkTo(ext::shared_ptr<ShortRateModel>());
        }

using QuantLib::OneFactorAffineModel;
using QuantLib::Vasicek;
using QuantLib::HullWhite;
using QuantLib::BlackKarasinski;
using QuantLib::G2;
using QuantLib::CoxIngersollRoss;
using QuantLib::ExtendedCoxIngersollRoss;


using QuantLib::JamshidianSwaptionEngine;
using QuantLib::TreeSwaptionEngine;
using QuantLib::AnalyticCapFloorEngine;
using QuantLib::TreeCapFloorEngine;
using QuantLib::G2SwaptionEngine;
using QuantLib::FdG2SwaptionEngine;
using QuantLib::FdHullWhiteSwaptionEngine;


using QuantLib::AnalyticBSMHullWhiteEngine;


using QuantLib::Bond;
typedef Bond::Price BondPrice;
using QuantLib::ZeroCouponBond;
using QuantLib::FixedRateBond;
using QuantLib::AmortizingFixedRateBond;
using QuantLib::FloatingRateBond;
using QuantLib::AmortizingFloatingRateBond;
using QuantLib::DiscountingBondEngine;
using QuantLib::simplifyNotificationGraph;


    Real cleanPriceFromZSpread(
                   const Bond& bond,
                   const ext::shared_ptr<YieldTermStructure>& discountCurve,
                   Spread zSpread,
                   const DayCounter& dc,
                   Compounding compounding,
                   Frequency freq,
                   const Date& settlementDate = Date()) {
        return QuantLib::BondFunctions::cleanPrice(
                                  bond,
                                  discountCurve,
                                  zSpread, dc, compounding,
                                  freq, settlementDate);
    }



using QuantLib::CmsRateBond;
using QuantLib::AmortizingCmsRateBond;


using QuantLib::CallableBond;
using QuantLib::Callability;
using QuantLib::SoftCallability;
using QuantLib::CallabilitySchedule;

using QuantLib::CallableFixedRateBond;
using QuantLib::CallableZeroCouponBond;
using QuantLib::TreeCallableFixedRateBondEngine;
using QuantLib::BlackCallableFixedRateBondEngine;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< Callability >, std::allocator< ext::shared_ptr< Callability > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< Callability >" "," "std::allocator< ext::shared_ptr< Callability > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__iterator(std::vector< ext::shared_ptr< Callability > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< Callability > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____bool__(std::vector< ext::shared_ptr< Callability > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::size_type std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____len__(std::vector< ext::shared_ptr< Callability > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____getslice__(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::difference_type i,std::vector< ext::shared_ptr< Callability > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::difference_type i,std::vector< ext::shared_ptr< Callability > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::difference_type i,std::vector< ext::shared_ptr< Callability > >::difference_type j,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____delslice__(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::difference_type i,std::vector< ext::shared_ptr< Callability > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< Callability > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< Callability > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< Callability > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< Callability > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< Callability > > const *self,std::vector< ext::shared_ptr< Callability > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::difference_type i,std::vector< ext::shared_ptr< Callability > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::value_type std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__pop(std::vector< ext::shared_ptr< Callability > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__append(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::iterator first,std::vector< ext::shared_ptr< Callability > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< Callability > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::iterator pos,std::vector< ext::shared_ptr< Callability > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< Callability > > *self,std::vector< ext::shared_ptr< Callability > >::iterator pos,std::vector< ext::shared_ptr< Callability > >::size_type n,std::vector< ext::shared_ptr< Callability > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::CPIBond;


using QuantLib::BondFunctions;

SWIGINTERN Rate BondFunctions_yieldBrent__SWIG_0(Brent solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Brent>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldBisection__SWIG_0(Bisection solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Bisection>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldFalsePosition__SWIG_0(FalsePosition solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<FalsePosition>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldRidder__SWIG_0(Ridder solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Ridder>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldSecant__SWIG_0(Secant solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Secant>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldNewton__SWIG_0(Newton solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<Newton>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }
SWIGINTERN Rate BondFunctions_yieldNewtonSafe__SWIG_0(NewtonSafe solver,Bond const &bond,Real cleanPrice,DayCounter const &dayCounter,Compounding compounding,Frequency frequency,Date settlementDate=Date(),Real accuracy=1.0e-10,Rate guess=0.05){
            return QuantLib::BondFunctions::yield<NewtonSafe>(
                        solver,
                        bond,
                        cleanPrice,
                        dayCounter,
                        compounding,
                        frequency,
                        settlementDate,
                        accuracy,
                        guess);
        }

using QuantLib::VanillaSwap;
using QuantLib::Swaption;
using QuantLib::BlackCalibrationHelper;
using QuantLib::SwaptionHelper;
using QuantLib::CapHelper;
using QuantLib::HestonModelHelper;


    ext::shared_ptr<BlackCalibrationHelper> as_black_helper(const ext::shared_ptr<CalibrationHelper>& h) {
        return ext::dynamic_pointer_cast<BlackCalibrationHelper>(h);
    }
    ext::shared_ptr<SwaptionHelper> as_swaption_helper(const ext::shared_ptr<BlackCalibrationHelper>& h) {
        return ext::dynamic_pointer_cast<SwaptionHelper>(h);
    }

SWIGINTERN std::vector< Time,std::allocator< Time > > SwaptionHelper_times(SwaptionHelper *self){
            std::list<Time> l;
            self->addTimesTo(l);
            std::vector<Time> v;
            std::copy(l.begin(),l.end(),std::back_inserter(v));
            return v;
        }
SWIGINTERN Date SwaptionHelper_swaptionExpiryDate(SwaptionHelper *self){
            return self->swaption()->exercise()->date(0);
        }
SWIGINTERN Real SwaptionHelper_swaptionStrike(SwaptionHelper *self){
            return self->swaption()->underlyingSwap()->fixedRate();
        }
SWIGINTERN Real SwaptionHelper_swaptionNominal(SwaptionHelper *self){
            return self->swaption()->underlyingSwap()->nominal();
        }
SWIGINTERN Date SwaptionHelper_swaptionMaturityDate(SwaptionHelper *self){
            return self->swaption()->underlyingSwap()->fixedSchedule().dates().back();
        }
SWIGINTERN std::vector< Time,std::allocator< Time > > CapHelper_times(CapHelper *self){
            std::list<Time> l;
            self->addTimesTo(l);
            std::vector<Time> v;
            std::copy(l.begin(),l.end(),std::back_inserter(v));
            return v;
        }

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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< BlackCalibrationHelper >, std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< BlackCalibrationHelper >" "," "std::allocator< ext::shared_ptr< BlackCalibrationHelper > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__iterator(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____bool__(std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____len__(std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____getslice__(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j,std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____delslice__(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__pop(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__append(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator first,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< BlackCalibrationHelper > > *self,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::CapFloor;
using QuantLib::Cap;
using QuantLib::Floor;
using QuantLib::Collar;

SWIGINTERN Real const CapFloor_vega(CapFloor *self){
        return self->result<Real>("vega");
      }
SWIGINTERN std::vector< Real,std::allocator< Real > > const CapFloor_optionletsPrice(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsPrice");
      }
SWIGINTERN std::vector< Real,std::allocator< Real > > const CapFloor_optionletsVega(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsVega");
      }
SWIGINTERN std::vector< Real,std::allocator< Real > > const CapFloor_optionletsDelta(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsDelta");
      }
SWIGINTERN std::vector< DiscountFactor,std::allocator< DiscountFactor > > const CapFloor_optionletsDiscountFactor(CapFloor *self){
        return self->result<std::vector<DiscountFactor> >("optionletsDiscountFactor");
      }
SWIGINTERN std::vector< Rate,std::allocator< Rate > > const CapFloor_optionletsAtmForward(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsAtmForward");
      }
SWIGINTERN std::vector< Rate,std::allocator< Rate > > const CapFloor_optionletsStdDev(CapFloor *self){
        return self->result<std::vector<Real> >("optionletsStdDev");
      }

using QuantLib::BlackCapFloorEngine;


using QuantLib::BachelierCapFloorEngine;


using QuantLib::CliquetOption;


using QuantLib::AnalyticCliquetEngine;
using QuantLib::AnalyticPerformanceEngine;
using QuantLib::MCPerformanceEngine;

SWIGINTERN MCPerformanceEngine< PseudoRandom > *new_MCPerformanceEngine_Sl_PseudoRandom_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCPerformanceEngine<PseudoRandom>(process,
                                                brownianBridge,
                                                antitheticVariate,
                                                requiredSamples,
                                                requiredTolerance,
                                                maxSamples,
                                                seed);
        }
SWIGINTERN MCPerformanceEngine< LowDiscrepancy > *new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg_(ext::shared_ptr< GeneralizedBlackScholesProcess > process,bool brownianBridge=false,bool antitheticVariate=false,intOrNull requiredSamples=Null< Size >(),doubleOrNull requiredTolerance=Null< Real >(),intOrNull maxSamples=Null< Size >(),BigInteger seed=0){
            return new MCPerformanceEngine<LowDiscrepancy>(process,
                                                brownianBridge,
                                                antitheticVariate,
                                                requiredSamples,
                                                requiredTolerance,
                                                maxSamples,
                                                seed);
        }

using QuantLib::ConvertibleZeroCouponBond;
using QuantLib::ConvertibleFixedCouponBond;
using QuantLib::ConvertibleFloatingRateBond;
using QuantLib::BinomialConvertibleEngine;


using QuantLib::Forward;


using QuantLib::BondForward;
using QuantLib::FixedRateBondForward;
using QuantLib::FixedRateBond;
using QuantLib::BusinessDayConvention;
using QuantLib::Position;


using QuantLib::Futures;
using QuantLib::OvernightIndexFuture;


using QuantLib::Pillar;
using QuantLib::RateHelper;
using QuantLib::DepositRateHelper;
using QuantLib::FraRateHelper;
using QuantLib::FuturesRateHelper;
using QuantLib::SwapRateHelper;
using QuantLib::BondHelper;
using QuantLib::FixedRateBondHelper;
using QuantLib::OISRateHelper;
using QuantLib::DatedOISRateHelper;
using QuantLib::FxSwapRateHelper;
using QuantLib::OvernightIndexFutureRateHelper;
using QuantLib::SofrFutureRateHelper;
using QuantLib::ConstNotionalCrossCurrencyBasisSwapRateHelper;
using QuantLib::MtMCrossCurrencyBasisSwapRateHelper;
using QuantLib::IborIborBasisSwapRateHelper;
using QuantLib::OvernightIborBasisSwapRateHelper;
using QuantLib::ArithmeticOISRateHelper;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< RateHelper >, std::allocator< ext::shared_ptr< RateHelper > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< RateHelper >" "," "std::allocator< ext::shared_ptr< RateHelper > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__iterator(std::vector< ext::shared_ptr< RateHelper > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< RateHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____bool__(std::vector< ext::shared_ptr< RateHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::size_type std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____len__(std::vector< ext::shared_ptr< RateHelper > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____getslice__(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i,std::vector< ext::shared_ptr< RateHelper > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i,std::vector< ext::shared_ptr< RateHelper > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i,std::vector< ext::shared_ptr< RateHelper > >::difference_type j,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____delslice__(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i,std::vector< ext::shared_ptr< RateHelper > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< RateHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< RateHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< RateHelper > > const *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::difference_type i,std::vector< ext::shared_ptr< RateHelper > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::value_type std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__pop(std::vector< ext::shared_ptr< RateHelper > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__append(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::iterator first,std::vector< ext::shared_ptr< RateHelper > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< RateHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::iterator pos,std::vector< ext::shared_ptr< RateHelper > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< RateHelper > > *self,std::vector< ext::shared_ptr< RateHelper > >::iterator pos,std::vector< ext::shared_ptr< RateHelper > >::size_type n,std::vector< ext::shared_ptr< RateHelper > >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< BondHelper >, std::allocator< ext::shared_ptr< BondHelper > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< BondHelper >" "," "std::allocator< ext::shared_ptr< BondHelper > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__iterator(std::vector< ext::shared_ptr< BondHelper > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< BondHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____bool__(std::vector< ext::shared_ptr< BondHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::size_type std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____len__(std::vector< ext::shared_ptr< BondHelper > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____getslice__(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i,std::vector< ext::shared_ptr< BondHelper > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i,std::vector< ext::shared_ptr< BondHelper > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i,std::vector< ext::shared_ptr< BondHelper > >::difference_type j,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____delslice__(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i,std::vector< ext::shared_ptr< BondHelper > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< BondHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< BondHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< BondHelper > > const *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::difference_type i,std::vector< ext::shared_ptr< BondHelper > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::value_type std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__pop(std::vector< ext::shared_ptr< BondHelper > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__append(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::iterator first,std::vector< ext::shared_ptr< BondHelper > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< BondHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::iterator pos,std::vector< ext::shared_ptr< BondHelper > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< BondHelper > > *self,std::vector< ext::shared_ptr< BondHelper > >::iterator pos,std::vector< ext::shared_ptr< BondHelper > >::size_type n,std::vector< ext::shared_ptr< BondHelper > >::value_type const &x){ self->insert(pos, n, x); }

    const ext::shared_ptr<DepositRateHelper> as_depositratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<DepositRateHelper>(helper);
    }
	const ext::shared_ptr<FraRateHelper> as_fraratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<FraRateHelper>(helper);
    }
    const ext::shared_ptr<SwapRateHelper> as_swapratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<SwapRateHelper>(helper);
    }
    const ext::shared_ptr<OISRateHelper> as_oisratehelper(const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<OISRateHelper>(helper);
    }
    const ext::shared_ptr<ConstNotionalCrossCurrencyBasisSwapRateHelper> as_constnotionalcrosscurrencybasisswapratehelper(
            const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<ConstNotionalCrossCurrencyBasisSwapRateHelper>(helper);
    }
    const ext::shared_ptr<MtMCrossCurrencyBasisSwapRateHelper> as_mtmcrosscurrencybasisswapratehelper(
            const ext::shared_ptr<RateHelper> helper) {
        return ext::dynamic_pointer_cast<MtMCrossCurrencyBasisSwapRateHelper>(helper);
    }


using QuantLib::Discount;
using QuantLib::ZeroYield;
using QuantLib::ForwardRate;


using QuantLib::PiecewiseYieldCurve;


struct _IterativeBootstrap {
    double accuracy, minValue, maxValue;
    Size maxAttempts;
    Real maxFactor, minFactor;
    bool dontThrow;
    Size dontThrowSteps, maxEvaluations;
    _IterativeBootstrap(double accuracy = Null<double>(),
                        double minValue = Null<double>(),
                        double maxValue = Null<double>(),
                        Size maxAttempts = 1,
                        Real maxFactor = 2.0,
                        Real minFactor = 2.0,
                        bool dontThrow = false,
                        Size dontThrowSteps = 10,
                        Size maxEvaluations = 100)
    : accuracy(accuracy), minValue(minValue), maxValue(maxValue),
      maxAttempts(maxAttempts), maxFactor(maxFactor), minFactor(minFactor),
      dontThrow(dontThrow), dontThrowSteps(dontThrowSteps),
      maxEvaluations(maxEvaluations) {}
};

template <class PiecewiseYieldCurve>
inline typename PiecewiseYieldCurve::bootstrap_type make_bootstrap(const _IterativeBootstrap& b) {
    return {
        b.accuracy, b.minValue, b.maxValue,
        b.maxAttempts, b.maxFactor, b.minFactor,
        b.dontThrow, b.dontThrowSteps,
        b.maxEvaluations
    };
}


typedef PiecewiseYieldCurve<ForwardRate, BackwardFlat> PiecewiseFlatForward;

SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseFlatForward>(b));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseFlatForward>(b));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatForward(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseFlatForward>(b));
        }
SWIGINTERN PiecewiseFlatForward *new_PiecewiseFlatForward__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,BackwardFlat const &i=BackwardFlat()){
            return new PiecewiseFlatForward(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseFlatForward>(b));
        }

typedef PiecewiseYieldCurve<Discount, LogLinear> PiecewiseLogLinearDiscount;

SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),LogLinear const &i=LogLinear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogLinearDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),LogLinear const &i=LogLinear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogLinearDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogLinear const &i=LogLinear()){
            return new PiecewiseLogLinearDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }
SWIGINTERN PiecewiseLogLinearDiscount *new_PiecewiseLogLinearDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogLinear const &i=LogLinear()){
            return new PiecewiseLogLinearDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLogLinearDiscount>(b));
        }

typedef PiecewiseYieldCurve<ForwardRate, Linear> PiecewiseLinearForward;

SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLinearForward>(b));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLinearForward>(b));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearForward(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLinearForward>(b));
        }
SWIGINTERN PiecewiseLinearForward *new_PiecewiseLinearForward__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearForward(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLinearForward>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, Linear> PiecewiseLinearZero;

SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLinearZero>(b));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Linear const &i=Linear(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLinearZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLinearZero>(b));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLinearZero>(b));
        }
SWIGINTERN PiecewiseLinearZero *new_PiecewiseLinearZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Linear const &i=Linear()){
            return new PiecewiseLinearZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLinearZero>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, Cubic> PiecewiseCubicZero;

SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Cubic const &i=Cubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseCubicZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseCubicZero>(b));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Cubic const &i=Cubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseCubicZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseCubicZero>(b));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Cubic const &i=Cubic()){
            return new PiecewiseCubicZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseCubicZero>(b));
        }
SWIGINTERN PiecewiseCubicZero *new_PiecewiseCubicZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Cubic const &i=Cubic()){
            return new PiecewiseCubicZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseCubicZero>(b));
        }

typedef PiecewiseYieldCurve<Discount, MonotonicLogCubic> PiecewiseLogCubicDiscount;

SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),MonotonicLogCubic const &i=MonotonicLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),MonotonicLogCubic const &i=MonotonicLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,MonotonicLogCubic const &i=MonotonicLogCubic()){
            return new PiecewiseLogCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogCubicDiscount *new_PiecewiseLogCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,MonotonicLogCubic const &i=MonotonicLogCubic()){
            return new PiecewiseLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLogCubicDiscount>(b));
        }

typedef PiecewiseYieldCurve<Discount, SplineCubic> PiecewiseSplineCubicDiscount;

SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseSplineCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseSplineCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseSplineCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }
SWIGINTERN PiecewiseSplineCubicDiscount *new_PiecewiseSplineCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseSplineCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseSplineCubicDiscount>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, Kruger> PiecewiseKrugerZero;

SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Kruger const &i=Kruger(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseKrugerZero>(b));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),Kruger const &i=Kruger(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseKrugerZero>(b));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Kruger const &i=Kruger()){
            return new PiecewiseKrugerZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseKrugerZero>(b));
        }
SWIGINTERN PiecewiseKrugerZero *new_PiecewiseKrugerZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,Kruger const &i=Kruger()){
            return new PiecewiseKrugerZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseKrugerZero>(b));
        }

typedef PiecewiseYieldCurve<Discount, KrugerLog> PiecewiseKrugerLogDiscount;

SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),KrugerLog const &i=KrugerLog(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerLogDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),KrugerLog const &i=KrugerLog(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseKrugerLogDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,KrugerLog const &i=KrugerLog()){
            return new PiecewiseKrugerLogDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }
SWIGINTERN PiecewiseKrugerLogDiscount *new_PiecewiseKrugerLogDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,KrugerLog const &i=KrugerLog()){
            return new PiecewiseKrugerLogDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseKrugerLogDiscount>(b));
        }

typedef PiecewiseYieldCurve<ForwardRate, ConvexMonotone> PiecewiseConvexMonotoneForward;

SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneForward(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneForward(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneForward(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneForward *new_PiecewiseConvexMonotoneForward__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneForward(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseConvexMonotoneForward>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, ConvexMonotone> PiecewiseConvexMonotoneZero;

SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),ConvexMonotone const &i=ConvexMonotone(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseConvexMonotoneZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }
SWIGINTERN PiecewiseConvexMonotoneZero *new_PiecewiseConvexMonotoneZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,ConvexMonotone const &i=ConvexMonotone()){
            return new PiecewiseConvexMonotoneZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseConvexMonotoneZero>(b));
        }

typedef PiecewiseYieldCurve<ZeroYield, SplineCubic> PiecewiseNaturalCubicZero;

SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalCubicZero(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }
SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),SplineCubic const &i=SplineCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalCubicZero(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }
SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseNaturalCubicZero(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }
SWIGINTERN PiecewiseNaturalCubicZero *new_PiecewiseNaturalCubicZero__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineCubic const &i=SplineCubic()){
            return new PiecewiseNaturalCubicZero(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseNaturalCubicZero>(b));
        }

typedef PiecewiseYieldCurve<Discount, SplineLogCubic> PiecewiseNaturalLogCubicDiscount;

SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),SplineLogCubic const &i=SplineLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalLogCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),SplineLogCubic const &i=SplineLogCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseNaturalLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineLogCubic const &i=SplineLogCubic()){
            return new PiecewiseNaturalLogCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }
SWIGINTERN PiecewiseNaturalLogCubicDiscount *new_PiecewiseNaturalLogCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,SplineLogCubic const &i=SplineLogCubic()){
            return new PiecewiseNaturalLogCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseNaturalLogCubicDiscount>(b));
        }

typedef PiecewiseYieldCurve<Discount, LogMixedLinearCubic> PiecewiseLogMixedLinearCubicDiscount;

SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),LogMixedLinearCubic const &i=LogMixedLinearCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogMixedLinearCubicDiscount(referenceDate, instruments, dayCounter, jumps, jumpDates,
                            i, make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &jumps=std::vector< Handle< Quote > >(),std::vector< Date,std::allocator< Date > > const &jumpDates=std::vector< Date >(),LogMixedLinearCubic const &i=LogMixedLinearCubic(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseLogMixedLinearCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            jumps, jumpDates, i, make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogMixedLinearCubic const &i=LogMixedLinearCubic()){
            return new PiecewiseLogMixedLinearCubicDiscount(referenceDate, instruments, dayCounter, i,
                            make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }
SWIGINTERN PiecewiseLogMixedLinearCubicDiscount *new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b,LogMixedLinearCubic const &i=LogMixedLinearCubic()){
            return new PiecewiseLogMixedLinearCubicDiscount(settlementDays, calendar, instruments, dayCounter,
                            i, make_bootstrap<PiecewiseLogMixedLinearCubicDiscount>(b));
        }

class AdditionalErrors {
    std::vector<ext::shared_ptr<RateHelper> > additionalHelpers_;
  public:
    AdditionalErrors(const std::vector<ext::shared_ptr<RateHelper> >& additionalHelpers)
    : additionalHelpers_(additionalHelpers) {}
    Array operator()() const {
        Array errors(additionalHelpers_.size() - 2);
        Real a = additionalHelpers_.front()->impliedQuote();
        Real b = additionalHelpers_.back()->impliedQuote();
        for (Size k = 0; k < errors.size(); ++k) {
            errors[k] = (static_cast<Real>(errors.size()-k) * a + static_cast<Real>(1+k) * b) / static_cast<Real>(errors.size()+1)
                - additionalHelpers_.at(1+k)->impliedQuote();
        }
        return errors;
    }
};

class AdditionalDates {
    std::vector<Date> additionalDates_;
  public:
    AdditionalDates(const std::vector<Date>& additionalDates)
    : additionalDates_(additionalDates) {}
    std::vector<Date> operator()() const {
        return additionalDates_;
    }
};

struct _GlobalBootstrap {
    std::vector<ext::shared_ptr<RateHelper> > additionalHelpers;
    std::vector<Date> additionalDates;
    double accuracy;
    _GlobalBootstrap(double accuracy = Null<double>())
    : accuracy(accuracy) {}
   _GlobalBootstrap(const std::vector<ext::shared_ptr<RateHelper> >& additionalHelpers,
                     const std::vector<Date>& additionalDates,
                     double accuracy = Null<double>())
    : additionalHelpers(additionalHelpers), additionalDates(additionalDates), accuracy(accuracy) {}
};


using QuantLib::SimpleZeroYield;
typedef PiecewiseYieldCurve<SimpleZeroYield, Linear, QuantLib::GlobalBootstrap>
    GlobalLinearSimpleZeroCurve;

SWIGINTERN GlobalLinearSimpleZeroCurve *new_GlobalLinearSimpleZeroCurve(Date const &referenceDate,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &instruments,DayCounter const &dayCounter,_GlobalBootstrap const &b){
            if (b.additionalHelpers.empty()) {
                return new GlobalLinearSimpleZeroCurve(
                    referenceDate, instruments, dayCounter, Linear(),
                    GlobalLinearSimpleZeroCurve::bootstrap_type(b.accuracy));
            } else {
                return new GlobalLinearSimpleZeroCurve(
                    referenceDate, instruments, dayCounter, Linear(),
                    GlobalLinearSimpleZeroCurve::bootstrap_type(b.additionalHelpers,
                                                                AdditionalDates(b.additionalDates),
                                                                AdditionalErrors(b.additionalHelpers),
                                                                b.accuracy));
            }
        }

using QuantLib::DefaultProbabilityTermStructure;

SWIGINTERN bool Handle_Sl_DefaultProbabilityTermStructure_Sg____nonzero__(Handle< DefaultProbabilityTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_DefaultProbabilityTermStructure_Sg____bool__(Handle< DefaultProbabilityTermStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_DefaultProbabilityTermStructure_Sg__asObservable(Handle< DefaultProbabilityTermStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_DefaultProbabilityTermStructure_Sg__reset(RelinkableHandle< DefaultProbabilityTermStructure > *self){
            self->linkTo(ext::shared_ptr<DefaultProbabilityTermStructure>());
        }

using QuantLib::FlatHazardRate;


using QuantLib::InterpolatedHazardRateCurve;


using QuantLib::InterpolatedDefaultDensityCurve;


using QuantLib::InterpolatedSurvivalProbabilityCurve;


using QuantLib::DefaultProbabilityHelper;
using QuantLib::SpreadCdsHelper;
using QuantLib::UpfrontCdsHelper;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< DefaultProbabilityHelper >, std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< DefaultProbabilityHelper >" "," "std::allocator< ext::shared_ptr< DefaultProbabilityHelper > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__iterator(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____bool__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____len__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____getslice__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____delslice__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type id = i;
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__pop(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__append(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator first,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *self,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::HazardRate;
using QuantLib::DefaultDensity;


using QuantLib::PiecewiseDefaultCurve;


typedef PiecewiseDefaultCurve<HazardRate, BackwardFlat> PiecewiseFlatHazardRate;

SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_0(Date const &referenceDate,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &instruments,DayCounter const &dayCounter,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatHazardRate(referenceDate, instruments, dayCounter,
                            i, PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_3(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &instruments,DayCounter const &dayCounter,BackwardFlat const &i=BackwardFlat(),_IterativeBootstrap const &b=_IterativeBootstrap()){
            return new PiecewiseFlatHazardRate(settlementDays, calendar, instruments, dayCounter,
                            i, PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_6(Date const &referenceDate,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseFlatHazardRate(referenceDate, instruments, dayCounter,
                            BackwardFlat(), PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }
SWIGINTERN PiecewiseFlatHazardRate *new_PiecewiseFlatHazardRate__SWIG_7(Integer settlementDays,Calendar const &calendar,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &instruments,DayCounter const &dayCounter,_IterativeBootstrap const &b){
            return new PiecewiseFlatHazardRate(settlementDays, calendar, instruments, dayCounter,
                            BackwardFlat(), PiecewiseFlatHazardRate::bootstrap_type(b.accuracy, b.minValue, b.maxValue));
        }

using QuantLib::RiskyBondEngine;


using QuantLib::Protection;


using QuantLib::CreditDefaultSwap;
using QuantLib::MidPointCdsEngine;
using QuantLib::IntegralCdsEngine;
using QuantLib::IsdaCdsEngine;
using QuantLib::Claim;
using QuantLib::FaceValueClaim;
using QuantLib::FaceValueAccrualClaim;
using QuantLib::CdsOption;
using QuantLib::BlackCdsOptionEngine;

SWIGINTERN doubleOrNull CreditDefaultSwap_upfront(CreditDefaultSwap const *self){
            ext::optional<Rate> result =
                self->upfront();
            if (result)
                return *result;
            else
                return Null<double>();
        }

using QuantLib::InterpolatedDiscountCurve;


using QuantLib::NormalDistribution;
using QuantLib::CumulativeNormalDistribution;
using QuantLib::MoroInverseCumulativeNormal;
using QuantLib::InverseCumulativeNormal;
using QuantLib::BivariateCumulativeNormalDistribution;
using QuantLib::BinomialDistribution;
using QuantLib::CumulativeBinomialDistribution;
using QuantLib::BivariateCumulativeNormalDistributionDr78;
using QuantLib::BivariateCumulativeNormalDistributionWe04DP;
using QuantLib::CumulativeChiSquareDistribution;
using QuantLib::NonCentralCumulativeChiSquareDistribution;
using QuantLib::InverseNonCentralCumulativeChiSquareDistribution;
using QuantLib::CumulativeGammaDistribution;
using QuantLib::GammaFunction;
using QuantLib::PoissonDistribution;
using QuantLib::CumulativePoissonDistribution;
using QuantLib::InverseCumulativePoisson;
using QuantLib::StudentDistribution;
using QuantLib::CumulativeStudentDistribution;
using QuantLib::InverseCumulativeStudent;


using QuantLib::Money;

SWIGINTERN Money Money_operator_Sa_(Money *self,Money const &m){ return *self+m; }
SWIGINTERN Money Money_operator_Ss_(Money *self,Money const &m){ return *self-m; }
SWIGINTERN Money Money_operator_Sm_(Money *self,Decimal x){ return *self*x; }
SWIGINTERN Money Money_operator_Sd___SWIG_0(Money *self,Decimal x){ return *self/x; }
SWIGINTERN Decimal Money_operator_Sd___SWIG_1(Money *self,Money const &m){ return *self/m; }
SWIGINTERN Money Money___rmul__(Money *self,Decimal x){ return *self*x; }
SWIGINTERN bool Money___lt__(Money *self,Money const &other){
            return *self < other;
        }
SWIGINTERN bool Money___gt__(Money *self,Money const &other){
            return other < *self;
        }
SWIGINTERN bool Money___le__(Money *self,Money const &other){
            return !(other < *self);
        }
SWIGINTERN bool Money___ge__(Money *self,Money const &other){
            return !(*self < other);
        }
SWIGINTERN int Money___cmp__(Money *self,Money const &other){
            if (*self < other)
                return -1;
            else if (*self == other)
                return 0;
            else
                return 1;
        }
SWIGINTERN std::string Money___str__(Money *self){
            std::ostringstream out;
            out << *self;
            return out.str();
        }
SWIGINTERN void Money_setConversionType(Money::ConversionType type){
            Money::Settings::instance().conversionType() = type;
        }
SWIGINTERN void Money_setBaseCurrency(Currency const &c){
            Money::Settings::instance().baseCurrency() = c;
        }

using QuantLib::ExchangeRate;
using QuantLib::ExchangeRateManager;


using QuantLib::Settings;

SWIGINTERN Date Settings_getEvaluationDate(Settings *self){
            return self->evaluationDate();
        }
SWIGINTERN void Settings_setEvaluationDate(Settings *self,Date const &d){
            self->evaluationDate() = d;
        }
SWIGINTERN void Settings_includeReferenceDateEvents(Settings *self,bool b){
            self->includeReferenceDateEvents() = b;
        }
SWIGINTERN void Settings_includeTodaysCashFlows(Settings *self,bool b){
            self->includeTodaysCashFlows() = b;
        }
SWIGINTERN void Settings_setEnforcesTodaysHistoricFixings(Settings *self,bool b){
            self->enforcesTodaysHistoricFixings() = b;
        }
SWIGINTERN bool Settings_getEnforcesTodaysHistoricFixings(Settings *self){
            return self->enforcesTodaysHistoricFixings();
        }

using QuantLib::Fdm1dMesher;
using QuantLib::FdmBlackScholesMesher;
using QuantLib::Concentrating1dMesher;
using QuantLib::ExponentialJump1dMesher;
using QuantLib::FdmQuantoHelper;
using QuantLib::FdmCEV1dMesher;
using QuantLib::FdmHestonVarianceMesher;
using QuantLib::FdmHestonLocalVolatilityVarianceMesher;
using QuantLib::Uniform1dMesher;
using QuantLib::FdmSimpleProcess1dMesher;
using QuantLib::Predefined1dMesher;
using QuantLib::Glued1dMesher;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< Fdm1dMesher >, std::allocator< ext::shared_ptr< Fdm1dMesher > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< Fdm1dMesher >" "," "std::allocator< ext::shared_ptr< Fdm1dMesher > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__iterator(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< Fdm1dMesher > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____bool__(std::vector< ext::shared_ptr< Fdm1dMesher > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____len__(std::vector< ext::shared_ptr< Fdm1dMesher > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____getslice__(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j,std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____delslice__(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type id = i;
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > const *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__pop(std::vector< ext::shared_ptr< Fdm1dMesher > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__append(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator first,std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< Fdm1dMesher > > *self,std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos,std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__first(ext::tuple< Real,Real,bool > const *self){
        return ext::get<0>(*self);
      }
SWIGINTERN double ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__second(ext::tuple< Real,Real,bool > const *self){
        return ext::get<1>(*self);
      }
SWIGINTERN bool ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__third(ext::tuple< Real,Real,bool > const *self){
        return ext::get<2>(*self);
      }

  namespace swig {
    template <>  struct traits< ext::tuple< Real,Real,bool > > {
      typedef pointer_category category;
      static const char* type_name() { return"ext::tuple< Real,Real,bool >"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< ext::tuple< Real,Real,bool >, std::allocator< ext::tuple< Real,Real,bool > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::tuple< Real,Real,bool >" "," "std::allocator< ext::tuple< Real,Real,bool > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__iterator(std::vector< ext::tuple< Real,Real,bool > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____nonzero__(std::vector< ext::tuple< Real,Real,bool > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____bool__(std::vector< ext::tuple< Real,Real,bool > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::size_type std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____len__(std::vector< ext::tuple< Real,Real,bool > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____getslice__(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::difference_type i,std::vector< ext::tuple< double,double,bool > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setslice____SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::difference_type i,std::vector< ext::tuple< double,double,bool > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >());
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setslice____SWIG_1(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::difference_type i,std::vector< ext::tuple< double,double,bool > >::difference_type j,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____delslice__(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::difference_type i,std::vector< ext::tuple< double,double,bool > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____delitem____SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____getitem____SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type id = i;
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setitem____SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type id = i;
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setitem____SWIG_1(std::vector< ext::tuple< Real,Real,bool > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type id = i;
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____delitem____SWIG_1(std::vector< ext::tuple< Real,Real,bool > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type id = i;
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::value_type const &std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____getitem____SWIG_1(std::vector< ext::tuple< Real,Real,bool > > const *self,std::vector< ext::tuple< double,double,bool > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setitem____SWIG_2(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::difference_type i,std::vector< ext::tuple< double,double,bool > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::value_type std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__pop(std::vector< ext::tuple< Real,Real,bool > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__append(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::iterator std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__erase__SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::iterator std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__erase__SWIG_1(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::iterator first,std::vector< ext::tuple< double,double,bool > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::tuple< double,double,bool > >::iterator std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__insert__SWIG_0(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::iterator pos,std::vector< ext::tuple< double,double,bool > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__insert__SWIG_1(std::vector< ext::tuple< Real,Real,bool > > *self,std::vector< ext::tuple< double,double,bool > >::iterator pos,std::vector< ext::tuple< double,double,bool > >::size_type n,std::vector< ext::tuple< double,double,bool > >::value_type const &x){ self->insert(pos, n, x); }

using QuantLib::FdmLinearOpIterator;
using QuantLib::FdmLinearOpLayout;
using QuantLib::FdmMesher;
using QuantLib::FdmMesherComposite;

SWIGINTERN FdmLinearOpIterator *new_FdmLinearOpIterator__SWIG_0(std::vector< unsigned int,std::allocator< unsigned int > > const &dim){
            return new FdmLinearOpIterator(to_vector<Size>(dim));
        }
SWIGINTERN FdmLinearOpIterator *new_FdmLinearOpIterator__SWIG_1(std::vector< unsigned int,std::allocator< unsigned int > > const &dim,std::vector< unsigned int,std::allocator< unsigned int > > const &coordinates,Size index){
            return new FdmLinearOpIterator(to_vector<Size>(dim),
                                           to_vector<Size>(coordinates),
                                           index);
        }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > FdmLinearOpIterator_coordinates(FdmLinearOpIterator *self){
            return to_vector<unsigned int>(self->coordinates());
        }
SWIGINTERN void FdmLinearOpIterator_increment(FdmLinearOpIterator *self){
            ++(*self);
        }
SWIGINTERN bool FdmLinearOpIterator_notEqual(FdmLinearOpIterator *self,FdmLinearOpIterator const &iterator){
            return self->operator!=(iterator);
        }
SWIGINTERN FdmLinearOpLayout *new_FdmLinearOpLayout(std::vector< unsigned int,std::allocator< unsigned int > > const &dim){
            return new FdmLinearOpLayout(to_vector<Size>(dim));
        }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > FdmLinearOpLayout_spacing(FdmLinearOpLayout *self){
            return to_vector<unsigned int>(self->spacing());
        }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > FdmLinearOpLayout_dim(FdmLinearOpLayout const *self){
            return to_vector<unsigned int>(self->dim());
        }
SWIGINTERN Size FdmLinearOpLayout_index(FdmLinearOpLayout const *self,std::vector< unsigned int,std::allocator< unsigned int > > const &coordinates){
            return self->index(to_vector<Size>(coordinates));
        }

using QuantLib::FdmLinearOp;
using QuantLib::FdmLinearOpComposite;


class SparseMatrix {
  public:
    std::vector<unsigned int> row_idx, col_idx;
    std::vector<Real> data;    
};

SWIGINTERN ext::shared_ptr< SparseMatrix > FdmLinearOpComposite_to_sparse_matrix(FdmLinearOpComposite const *self){
            
            ext::shared_ptr<SparseMatrix> a = ext::make_shared<SparseMatrix>();
            
            const QuantLib::SparseMatrix m = self->toMatrix(); 
            
            Size entries(0);
            for (auto iter1 = m.begin1(); iter1 != m.end1(); ++iter1)
                entries+=std::distance(iter1.begin(), iter1.end());
        
            a->row_idx.reserve(entries);
            a->col_idx.reserve(entries);
            a->data.reserve(entries);
            
            for (auto iter1 = m.begin1(); iter1 != m.end1(); ++iter1)
                for (auto iter2 = iter1.begin(); iter2 != iter1.end(); ++iter2) {
                    a->row_idx.push_back(iter1.index1());
                    a->col_idx.push_back(iter2.index2());
                    a->data.push_back(*iter2);
                }
    
            return a;
        }

class FdmLinearOpCompositeProxy : public FdmLinearOpComposite {
  public:
      FdmLinearOpCompositeProxy(PyObject* callback) : callback_(callback) {
        Py_XINCREF(callback_);
    }

    FdmLinearOpCompositeProxy& operator=(const FdmLinearOpCompositeProxy& f) {
        if ((this != &f) && (callback_ != f.callback_)) {
            Py_XDECREF(callback_);
            callback_ = f.callback_;
            Py_XINCREF(callback_);
        }
        return *this;
    }
    
    FdmLinearOpCompositeProxy(const FdmLinearOpCompositeProxy& p) 
    : callback_(p.callback_) {
        Py_XINCREF(callback_);
    }

    ~FdmLinearOpCompositeProxy() {
        Py_XDECREF(callback_);
    }

    Size size() const {
        PyObject* pyResult = PyObject_CallMethod(callback_,"size", NULL);

        QL_ENSURE(pyResult != NULL,
                  "failed to call size() on Python object");

        Size result = PyInt_AsLong(pyResult);
        Py_XDECREF(pyResult);
        
        return result;    
    }

    void setTime(Time t1, Time t2) {
        PyObject* pyResult 
            = PyObject_CallMethod(callback_,"setTime","dd", t1, t2);

        QL_ENSURE(pyResult != NULL,
                  "failed to call setTime() on Python object");

        Py_XDECREF(pyResult);
    }

    Array apply(const Array& r) const {
        return apply(r, "apply");        
    }

    Array apply_mixed(const Array& r) const {
        return apply(r, "apply_mixed");        
    }

    Array apply_direction(Size direction, const Array& r) const {
        PyObject* pyArray = SWIG_NewPointerObj(
            SWIG_as_voidptr(&r), SWIGTYPE_p_Array, 0);
            
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, "apply_direction", "kO", 
                (unsigned long)(direction), pyArray);
            
        Py_XDECREF(pyArray); 
            
        return extractArray(pyResult, "apply_direction");        
    }

    Array solve_splitting(Size direction, const Array& r, Real s) const {
        PyObject* pyArray = SWIG_NewPointerObj(
            SWIG_as_voidptr(&r), SWIGTYPE_p_Array, 0);
            
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, "solve_splitting", "kOd", 
                (unsigned long)(direction), pyArray, s);
            
        Py_XDECREF(pyArray); 
            
        return extractArray(pyResult, "solve_splitting");        
    }

    Array preconditioner(const Array& r, Real s) const {
        PyObject* pyArray = SWIG_NewPointerObj(
            SWIG_as_voidptr(&r), SWIGTYPE_p_Array, 0);
            
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, "preconditioner", "Od",pyArray, s);
            
        Py_XDECREF(pyArray); 
            
        return extractArray(pyResult, "preconditioner");        
    }

  private:
    Array apply(const Array& r, const std::string& methodName) const {
        PyObject* pyArray = SWIG_NewPointerObj(
            SWIG_as_voidptr(&r), SWIGTYPE_p_Array, 0);
            
#if !defined(PY_VERSION_HEX) || PY_VERSION_HEX < 0x03040000         
        std::vector<char> cstr(
            methodName.c_str(), methodName.c_str() + methodName.size() + 1);  
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, &cstr[0], "O", pyArray);
#else
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, methodName.c_str(), "O", pyArray);
#endif            
        Py_XDECREF(pyArray); 
        
        return extractArray(pyResult, methodName);        
    }

  private:        
    PyObject* callback_;    
};


using QuantLib::FdmDiscountDirichletBoundary;
using QuantLib::FdmDirichletBoundary;
using QuantLib::BoundaryCondition;
using QuantLib::FdmTimeDepDirichletBoundary;
using QuantLib::FdmBlackScholesOp;
using QuantLib::Fdm2dBlackScholesOp;
using QuantLib::FdmBatesOp;
using QuantLib::FdmCEVOp;
using QuantLib::FdmG2Op;
using QuantLib::FdmHestonHullWhiteOp;
using QuantLib::FdmHestonOp;
using QuantLib::FdmHullWhiteOp;
using QuantLib::FdmLocalVolFwdOp;
using QuantLib::FdmOrnsteinUhlenbeckOp;
using QuantLib::FdmSabrOp;
using QuantLib::FdmZabrOp;
using QuantLib::FdmDupire1dOp;
using QuantLib::FdmBlackScholesFwdOp;
using QuantLib::FdmHestonFwdOp;
using QuantLib::FdmSquareRootFwdOp;

typedef BoundaryCondition<FdmLinearOp> FdmBoundaryCondition;
typedef std::vector<ext::shared_ptr<FdmBoundaryCondition> > FdmBoundaryConditionSet;


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


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< FdmBoundaryCondition >, std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< FdmBoundaryCondition >" "," "std::allocator< ext::shared_ptr< FdmBoundaryCondition > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__iterator(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____nonzero__(std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____bool__(std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____len__(std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____getslice__(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j,std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____delslice__(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type id = i;
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type id = i;
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type id = i;
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type id = i;
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__pop(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__append(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator first,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< FdmBoundaryCondition > > *self,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN FdmTimeDepDirichletBoundary *new_FdmTimeDepDirichletBoundary(ext::shared_ptr< FdmMesher > const &mesher,PyObject *function,Size direction,FdmTimeDepDirichletBoundary::Side side){

            const ext::function<Real(Real)> f = UnaryFunction(function);
            return new FdmTimeDepDirichletBoundary(
                mesher, f, direction, side);
        }

using QuantLib::TripleBandLinearOp;
using QuantLib::FirstDerivativeOp;
using QuantLib::SecondDerivativeOp;
using QuantLib::NinePointLinearOp;
using QuantLib::SecondOrderMixedDerivativeOp;
using QuantLib::NthOrderDerivativeOp;


using QuantLib::CraigSneydScheme;
using QuantLib::CrankNicolsonScheme;
using QuantLib::ImplicitEulerScheme;
using QuantLib::DouglasScheme;
using QuantLib::ExplicitEulerScheme;
using QuantLib::HundsdorferScheme;
using QuantLib::MethodOfLinesScheme;
using QuantLib::ModifiedCraigSneydScheme;


using QuantLib::StepCondition;
using QuantLib::FdmSnapshotCondition;
using QuantLib::FdmAmericanStepCondition;
using QuantLib::FdmArithmeticAverageCondition;
using QuantLib::FdmSimpleSwingCondition;
using QuantLib::FdmBermudanStepCondition;
using QuantLib::FdmSimpleStorageCondition;
using QuantLib::FdmSimpleSwingCondition;
using QuantLib::FdmDividendHandler;
using QuantLib::FdmInnerValueCalculator;
using QuantLib::FdmCellAveragingInnerValue;
using QuantLib::FdmLogInnerValue;
using QuantLib::FdmLogBasketInnerValue;
using QuantLib::FdmZeroInnerValue;
using QuantLib::FdmAffineModelSwapInnerValue;
using QuantLib::FdmStepConditionComposite;


class FdmStepConditionProxy : public StepCondition<Array> {
  public:
    FdmStepConditionProxy(PyObject* callback) : callback_(callback) {
        Py_XINCREF(callback_);
    }
    
    FdmStepConditionProxy(const FdmStepConditionProxy& p) 
    : callback_(p.callback_) {
        Py_XINCREF(callback_);
    }

    FdmStepConditionProxy& operator=(const FdmStepConditionProxy& f) {
        if ((this != &f) && (callback_ != f.callback_)) {
            Py_XDECREF(callback_);
            callback_ = f.callback_;
            Py_XINCREF(callback_);
        }
        return *this;
    }

    ~FdmStepConditionProxy() {
        Py_XDECREF(callback_);
    }

    void applyTo(Array& a, Time t) const {
        PyObject* pyArray = SWIG_NewPointerObj(
            SWIG_as_voidptr(&a), SWIGTYPE_p_Array, 0);
            
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, "applyTo", "Od",pyArray, t);

        Py_XDECREF(pyArray);
    }
    
  private:       
    PyObject* callback_;    
};


class FdmInnerValueCalculatorProxy : public FdmInnerValueCalculator {
  public:
    FdmInnerValueCalculatorProxy(PyObject* callback) : callback_(callback) {
        Py_XINCREF(callback_);
    }
    
    FdmInnerValueCalculatorProxy(const FdmInnerValueCalculatorProxy& p) 
    : callback_(p.callback_) {
        Py_XINCREF(callback_);
    }

    FdmInnerValueCalculatorProxy& operator=(const FdmInnerValueCalculatorProxy& f) {
        if ((this != &f) && (callback_ != f.callback_)) {
            Py_XDECREF(callback_);
            callback_ = f.callback_;
            Py_XINCREF(callback_);
        }
        return *this;
    }

    ~FdmInnerValueCalculatorProxy() {
        Py_XDECREF(callback_);
    }

    Real innerValue(const FdmLinearOpIterator& iter, Time t) {
        return getValue(iter, t, "innerValue");
    }

    Real avgInnerValue(const FdmLinearOpIterator& iter, Time t) {
        return getValue(iter, t, "avgInnerValue");
    }
    
  private: 
      Real getValue(const FdmLinearOpIterator& iter, Time t, const std::string& methodName) {
        PyObject* pyIter = SWIG_NewPointerObj(
            SWIG_as_voidptr(&iter), SWIGTYPE_p_FdmLinearOpIterator, 0);

#if !defined(PY_VERSION_HEX) || PY_VERSION_HEX < 0x03040000         
        std::vector<char> cstr(
            methodName.c_str(), methodName.c_str() + methodName.size() + 1);  
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, &cstr[0], "Od",pyIter, t);
#else
        PyObject* pyResult 
            = PyObject_CallMethod(callback_, methodName.c_str(), "Od", pyIter, t);
#endif            
            
        Py_XDECREF(pyIter);

        QL_ENSURE(pyResult != NULL, "failed to call innerValue function on Python object");

        const Real result = PyFloat_AsDouble(pyResult);

        Py_XDECREF(pyResult);

        return result;
      }
            
    PyObject* callback_;    
};

SWIGINTERN FdmCellAveragingInnerValue *new_FdmCellAveragingInnerValue__SWIG_0(ext::shared_ptr< Payoff > const &payoff,ext::shared_ptr< FdmMesher > const &mesher,Size direction,PyObject *gridMapping){

                UnaryFunction f(gridMapping);
                return new FdmCellAveragingInnerValue(payoff, mesher, direction, f);
        }
SWIGINTERN FdmCellAveragingInnerValue *new_FdmCellAveragingInnerValue__SWIG_1(ext::shared_ptr< Payoff > const &payoff,ext::shared_ptr< FdmMesher > const &mesher,Size direction){
                return new FdmCellAveragingInnerValue(payoff, mesher, direction);            
        }

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

  namespace swig {
    template <class ValueType>
    struct from_key_oper 
    {
      typedef const ValueType& argument_type;
      typedef  PyObject *result_type;
      result_type operator()(argument_type v) const
      {
	return swig::from(v.first);
      }
    };

    template <class ValueType>
    struct from_value_oper 
    {
      typedef const ValueType& argument_type;
      typedef  PyObject *result_type;
      result_type operator()(argument_type v) const
      {
	return swig::from(v.second);
      }
    };

    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
    {
      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
      {
      }
    };


    template<class OutIterator,
	     class FromOper = from_key_oper<typename OutIterator::value_type> >
    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
    {
      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
      {
      }
    };

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

    template<class OutIterator,
	     class FromOper = from_value_oper<typename OutIterator::value_type> >
    struct SwigPyMapValueIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
    {
      SwigPyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
      {
      }
    };
    

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


  namespace swig {
    template <class SwigPySeq, class K, class T, class Compare, class Alloc >
    inline void
    assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
      typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
      typename SwigPySeq::const_iterator it = swigpyseq.begin();
      for (;it != swigpyseq.end(); ++it) {
	map->insert(value_type(it->first, it->second));
      }
    }

    template <class K, class T, class Compare, class Alloc>
    struct traits_asptr<std::map<K,T,Compare,Alloc > >  {
      typedef std::map<K,T,Compare,Alloc > map_type;
      static int asptr(PyObject *obj, map_type **val) {
	int res = SWIG_ERROR;
	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	if (PyDict_Check(obj)) {
	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
#if PY_VERSION_HEX >= 0x03000000
          /* In Python 3.x the ".items()" method returns a dict_items object */
          items = PySequence_Fast(items, ".items() didn't return a sequence!");
#endif
	  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
	} else {
	  map_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<map_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	SWIG_PYTHON_THREAD_END_BLOCK;
	return res;
      }      
    };
      
    template <class K, class T, class Compare, class Alloc >
    struct traits_from<std::map<K,T,Compare,Alloc > >  {
      typedef std::map<K,T,Compare,Alloc > map_type;
      typedef typename map_type::const_iterator const_iterator;
      typedef typename map_type::size_type size_type;

      static PyObject *asdict(const map_type& map) {
	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	size_type size = map.size();
	Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
	if (pysize < 0) {
	  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	  SWIG_PYTHON_THREAD_END_BLOCK;
	  return NULL;
	}
	PyObject *obj = PyDict_New();
	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
	  swig::SwigVar_PyObject key = swig::from(i->first);
	  swig::SwigVar_PyObject val = swig::from(i->second);
	  PyDict_SetItem(obj, key, val);
	}
	SWIG_PYTHON_THREAD_END_BLOCK;
	return obj;
      }
                
      static PyObject *from(const map_type& map) {
	swig_type_info *desc = swig::type_info<map_type>();
	if (desc && desc->clientdata) {
	  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
	} else {
	  return asdict(map);
	}
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::map< double, Date, std::less< double >, std::allocator< std::pair< double const,Date > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "double" "," "Date" "," "std::less< double >" "," "std::allocator< std::pair< double const,Date > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_Time_Sc_Date_Sg__iterator(std::map< Time,Date > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_Time_Sc_Date_Sg____nonzero__(std::map< Time,Date > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_Time_Sc_Date_Sg____bool__(std::map< Time,Date > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< double,Date >::size_type std_map_Sl_Time_Sc_Date_Sg____len__(std::map< Time,Date > const *self){
      return self->size();
    }
SWIGINTERN std::map< double,Date >::mapped_type const &std_map_Sl_Time_Sc_Date_Sg____getitem__(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg____delitem__(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_Time_Sc_Date_Sg__has_key(std::map< Time,Date > const *self,std::map< double,Date >::key_type const &key){
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_Time_Sc_Date_Sg__keys(std::map< Time,Date > *self){
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_Time_Sc_Date_Sg__values(std::map< Time,Date > *self){
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_Time_Sc_Date_Sg__items(std::map< Time,Date > *self){
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_Time_Sc_Date_Sg____contains__(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_Time_Sc_Date_Sg__key_iterator(std::map< Time,Date > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_Time_Sc_Date_Sg__value_iterator(std::map< Time,Date > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg____setitem____SWIG_0(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg____setitem____SWIG_1(std::map< Time,Date > *self,std::map< double,Date >::key_type const &key,std::map< double,Date >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_Time_Sc_Date_Sg__asdict(std::map< Time,Date > *self){
      return swig::traits_from< std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg__erase__SWIG_1(std::map< Time,Date > *self,std::map< double,Date >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_Time_Sc_Date_Sg__erase__SWIG_2(std::map< Time,Date > *self,std::map< double,Date >::iterator first,std::map< double,Date >::iterator last){ self->erase(first, last); }

  namespace swig {
    template <>  struct traits< ext::shared_ptr< StepCondition< Array > > > {
      typedef pointer_category category;
      static const char* type_name() { return"ext::shared_ptr< StepCondition< Array > >"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< ext::shared_ptr< StepCondition< Array > >, std::allocator< ext::shared_ptr< StepCondition< Array > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "ext::shared_ptr< StepCondition< Array > >" "," "std::allocator< ext::shared_ptr< StepCondition< Array > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__iterator(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____nonzero__(std::vector< ext::shared_ptr< StepCondition< Array > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____bool__(std::vector< ext::shared_ptr< StepCondition< Array > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____len__(std::vector< ext::shared_ptr< StepCondition< Array > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____getslice__(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setslice____SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >());
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setslice____SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j,std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____delslice__(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____delitem____SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____getitem____SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setitem____SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setitem____SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____delitem____SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type id = i;
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____getitem____SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > const *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setitem____SWIG_2(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__pop(std::vector< ext::shared_ptr< StepCondition< Array > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__append(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__erase__SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__erase__SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator first,std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__insert__SWIG_0(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__insert__SWIG_1(std::vector< ext::shared_ptr< StepCondition< Array > > > *self,std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos,std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN FdmStepConditionComposite *new_FdmStepConditionComposite(std::vector< Time,std::allocator< Time > > const &stoppingTimes,std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &conditions){
            return new FdmStepConditionComposite(
                std::list<std::vector<Time> >(1, stoppingTimes), 
                std::list<ext::shared_ptr<StepCondition<Array> > >(
                    conditions.begin(), conditions.end()));
        }

using QuantLib::FdmSolverDesc;
using QuantLib::Fdm1DimSolver;
using QuantLib::FdmBackwardSolver;
using QuantLib::Fdm2dBlackScholesSolver;
using QuantLib::Fdm2DimSolver;
using QuantLib::Fdm3DimSolver;
using QuantLib::FdmG2Solver;
using QuantLib::FdmHestonHullWhiteSolver;
using QuantLib::FdmHestonSolver;
using QuantLib::FdmHullWhiteSolver;
using QuantLib::FdmNdimSolver;

SWIGINTERN FdmSolverDesc *new_FdmSolverDesc(ext::shared_ptr< FdmMesher > const &mesher,FdmBoundaryConditionSet const &bcSet,ext::shared_ptr< FdmStepConditionComposite > const &condition,ext::shared_ptr< FdmInnerValueCalculator > const &calculator,Time maturity,Size timeSteps,Size dampingSteps){
            
            const FdmSolverDesc desc = { 
                mesher, bcSet, condition, calculator, 
                maturity, timeSteps, dampingSteps };
            
            return new FdmSolverDesc(desc);            
        }
SWIGINTERN ext::shared_ptr< FdmMesher > FdmSolverDesc_getMesher(FdmSolverDesc const *self){ return self->mesher; }
SWIGINTERN FdmBoundaryConditionSet const &FdmSolverDesc_getBcSet(FdmSolverDesc const *self){ return self->bcSet; }
SWIGINTERN ext::shared_ptr< FdmStepConditionComposite > FdmSolverDesc_getStepConditions(FdmSolverDesc const *self){ return self->condition; }
SWIGINTERN ext::shared_ptr< FdmInnerValueCalculator > FdmSolverDesc_getCalculator(FdmSolverDesc const *self){ return self->calculator; }
SWIGINTERN Time FdmSolverDesc_getMaturity(FdmSolverDesc const *self){ return self->maturity; }
SWIGINTERN Size FdmSolverDesc_getTimeSteps(FdmSolverDesc const *self){ return self->timeSteps; }
SWIGINTERN Size FdmSolverDesc_getDampingSteps(FdmSolverDesc const *self){ return self->dampingSteps; }
SWIGINTERN Fdm2dBlackScholesSolver *new_Fdm2dBlackScholesSolver(ext::shared_ptr< GeneralizedBlackScholesProcess > const &p1,ext::shared_ptr< GeneralizedBlackScholesProcess > const &p2,Real const correlation,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer(),bool localVol=false,Real illegalLocalVolOverwrite=-Null< Real >()){
                return new Fdm2dBlackScholesSolver(
                    Handle<GeneralizedBlackScholesProcess>(p1), 
                    Handle<GeneralizedBlackScholesProcess>(p2), 
                    correlation, solverDesc, schemeDesc, 
                    localVol, illegalLocalVolOverwrite); 
        }
SWIGINTERN FdmG2Solver *new_FdmG2Solver__SWIG_0(ext::shared_ptr< G2 > const &model,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
                return new FdmG2Solver(Handle<G2>(model), solverDesc, schemeDesc);            
        }
SWIGINTERN FdmHestonHullWhiteSolver *new_FdmHestonHullWhiteSolver__SWIG_0(ext::shared_ptr< HestonProcess > const &hestonProcess,ext::shared_ptr< HullWhiteProcess > const &hwProcess,Rate corrEquityShortRate,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
                return new FdmHestonHullWhiteSolver(
                    Handle<HestonProcess>(hestonProcess),
                    Handle<HullWhiteProcess>(hwProcess),
                    corrEquityShortRate, solverDesc, schemeDesc);                    
        }
SWIGINTERN FdmHestonSolver *new_FdmHestonSolver(ext::shared_ptr< HestonProcess > const &process,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer(),ext::shared_ptr< FdmQuantoHelper > const &quantoHelper=ext::shared_ptr< FdmQuantoHelper >(),ext::shared_ptr< LocalVolTermStructure > const &leverageFct=ext::shared_ptr< LocalVolTermStructure >()){

                return new FdmHestonSolver(
                    Handle<HestonProcess>(process),
                    solverDesc, schemeDesc, 
                    Handle<FdmQuantoHelper>(quantoHelper), 
                    leverageFct);
        }
SWIGINTERN FdmHullWhiteSolver *new_FdmHullWhiteSolver__SWIG_0(ext::shared_ptr< HullWhite > const &model,FdmSolverDesc const &solverDesc,FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){
                return new FdmHullWhiteSolver(
                    Handle<HullWhite>(model), solverDesc, schemeDesc);
        }

using QuantLib::FdmIndicesOnBoundary;
using QuantLib::RiskNeutralDensityCalculator;
using QuantLib::BSMRNDCalculator;
using QuantLib::CEVRNDCalculator;
using QuantLib::GBSMRNDCalculator;
using QuantLib::HestonRNDCalculator;
using QuantLib::LocalVolRNDCalculator;
using QuantLib::SquareRootProcessRNDCalculator;

SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > FdmIndicesOnBoundary_getIndices(FdmIndicesOnBoundary const *self){
            return to_vector<unsigned int>(self->getIndices());
        }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > LocalVolRNDCalculator_rescaleTimeSteps(LocalVolRNDCalculator const *self){
            return to_vector<unsigned int>(self->rescaleTimeSteps());
        }

using QuantLib::FittedBondDiscountCurve;

typedef QuantLib::FittedBondDiscountCurve::FittingMethod FittingMethod;

std::vector<ext::shared_ptr<BondHelper> > convert_bond_helpers(
                 const std::vector<ext::shared_ptr<RateHelper> >& helpers) {
    std::vector<ext::shared_ptr<BondHelper> > result(helpers.size());
    for (Size i=0; i<helpers.size(); ++i)
        result[i] = ext::dynamic_pointer_cast<BondHelper>(helpers[i]);
    return result;
}


using QuantLib::ExponentialSplinesFitting;
using QuantLib::NelsonSiegelFitting;
using QuantLib::SvenssonFitting;
using QuantLib::CubicBSplinesFitting;
using QuantLib::SimplePolynomialFitting;
using QuantLib::SpreadFittingMethod;


using QuantLib::InterpolatedForwardCurve;


using QuantLib::Position;
using QuantLib::ForwardRateAgreement;


using QuantLib::Gaussian1dModel;


using QuantLib::Gsr;
using QuantLib::MarkovFunctional;


using QuantLib::Gaussian1dCapFloorEngine;
using QuantLib::Gaussian1dSwaptionEngine;
using QuantLib::Gaussian1dJamshidianSwaptionEngine;
using QuantLib::Gaussian1dNonstandardSwaptionEngine;
using QuantLib::Gaussian1dFloatFloatSwaptionEngine;


using QuantLib::SegmentIntegral;
using QuantLib::TrapezoidIntegral;
using QuantLib::Default;
using QuantLib::MidPoint;
using QuantLib::SimpsonIntegral;
using QuantLib::GaussKronrodAdaptive;
using QuantLib::GaussKronrodNonAdaptive;
using QuantLib::GaussLobattoIntegral;
using QuantLib::GaussLaguerreIntegration;
using QuantLib::GaussHermiteIntegration;
using QuantLib::GaussJacobiIntegration;
using QuantLib::GaussHyperbolicIntegration;
using QuantLib::GaussLegendreIntegration;
using QuantLib::GaussChebyshevIntegration;
using QuantLib::GaussChebyshev2ndIntegration;
using QuantLib::GaussGegenbauerIntegration;
using QuantLib::TanhSinhIntegral;
using QuantLib::ExpSinhIntegral;

SWIGINTERN Real SegmentIntegral___call__(SegmentIntegral *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real TrapezoidIntegral_Sl_Default_Sg____call__(TrapezoidIntegral< Default > *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real TrapezoidIntegral_Sl_MidPoint_Sg____call__(TrapezoidIntegral< MidPoint > *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real SimpsonIntegral___call__(SimpsonIntegral *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real GaussKronrodAdaptive___call__(GaussKronrodAdaptive *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real GaussKronrodNonAdaptive___call__(GaussKronrodNonAdaptive *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real GaussLobattoIntegral___call__(GaussLobattoIntegral *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }

using QuantLib::GaussianQuadrature;

SWIGINTERN Array GaussianQuadrature_weights(GaussianQuadrature *self){ 
        return self->weights(); 
      }
SWIGINTERN Array GaussianQuadrature_x(GaussianQuadrature *self){ 
        return self->x(); 
      }
SWIGINTERN Real GaussianQuadrature___call__(GaussianQuadrature *self,PyObject *pyFunction){
          UnaryFunction f(pyFunction);
          return (*self)(f);
      }
SWIGINTERN Real TanhSinhIntegral___call__(TanhSinhIntegral *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }
SWIGINTERN Real ExpSinhIntegral_integrate(ExpSinhIntegral *self,PyObject *pyFunction){
            UnaryFunction f(pyFunction);
            return self->integrate(f);
        }
SWIGINTERN Real ExpSinhIntegral___call__(ExpSinhIntegral *self,PyObject *pyFunction,Real a,Real b){
            UnaryFunction f(pyFunction);
            return (*self)(f, a, b);
        }

using QuantLib::LocalConstantVol;


using QuantLib::LocalVolSurface;


using QuantLib::NoExceptLocalVolSurface;


using QuantLib::FixedLocalVolSurface;
using QuantLib::GridModelLocalVolSurface;

SWIGINTERN FixedLocalVolSurface *new_FixedLocalVolSurface__SWIG_0(Date const &referenceDate,std::vector< Date,std::allocator< Date > > const &dates,std::vector< Real,std::allocator< Real > > const &strikes,Matrix localVolMatrix,DayCounter const &dayCounter,FixedLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,FixedLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            ext::shared_ptr<Matrix> pMatrix = ext::make_shared<Matrix>(localVolMatrix);
            return new FixedLocalVolSurface(referenceDate, dates, strikes, pMatrix,
                                            dayCounter, lowerExtrapolation, upperExtrapolation);
        }
SWIGINTERN FixedLocalVolSurface *new_FixedLocalVolSurface__SWIG_3(Date const &referenceDate,std::vector< Time,std::allocator< Time > > const &times,std::vector< Real,std::allocator< Real > > const &strikes,Matrix localVolMatrix,DayCounter const &dayCounter,FixedLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,FixedLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            ext::shared_ptr<Matrix> pMatrix = ext::make_shared<Matrix>(localVolMatrix);
            return new FixedLocalVolSurface(referenceDate, times, strikes, pMatrix,
                                            dayCounter, lowerExtrapolation, upperExtrapolation);
        }
SWIGINTERN FixedLocalVolSurface *new_FixedLocalVolSurface__SWIG_6(Date const &referenceDate,std::vector< Time,std::allocator< Time > > const &times,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &strikes,Matrix localVolMatrix,DayCounter const &dayCounter,FixedLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,FixedLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            std::vector<ext::shared_ptr<std::vector<Real> > > pStrikes(strikes.size());
            for (Size i=0; i<strikes.size(); ++i)
                pStrikes[i] = ext::make_shared<std::vector<Real>>(strikes[i]);
            ext::shared_ptr<Matrix> pMatrix = ext::make_shared<Matrix>(localVolMatrix);
            return new FixedLocalVolSurface(referenceDate, times, pStrikes, pMatrix,
                                            dayCounter, lowerExtrapolation, upperExtrapolation);
        }
SWIGINTERN void FixedLocalVolSurface_setInterpolation__SWIG_0(FixedLocalVolSurface *self,std::string const &interpolator=""){
            const std::string s = boost::to_lower_copy(interpolator);
            if (s == "" || s == "linear") {
                self->setInterpolation<QuantLib::Linear>();
            } else if (s == "cubic") {
                self->setInterpolation<QuantLib::Cubic>();
            } else {
                QL_FAIL("Unknown interpolator: " << interpolator);
            }
        }
SWIGINTERN GridModelLocalVolSurface *new_GridModelLocalVolSurface__SWIG_0(Date const &referenceDate,std::vector< Date,std::allocator< Date > > const &dates,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &strikes,DayCounter const &dayCounter,GridModelLocalVolSurface::Extrapolation lowerExtrapolation=FixedLocalVolSurface::ConstantExtrapolation,GridModelLocalVolSurface::Extrapolation upperExtrapolation=FixedLocalVolSurface::ConstantExtrapolation){
            std::vector<ext::shared_ptr<std::vector<Real> > > pStrikes(strikes.size());
            for (Size i=0; i<strikes.size(); ++i)
                pStrikes[i] = ext::make_shared<std::vector<Real>>(strikes[i]);
            return new GridModelLocalVolSurface(referenceDate, dates, pStrikes,
                                                dayCounter, lowerExtrapolation, upperExtrapolation);
        }

using QuantLib::Sample;

using QuantLib::LecuyerUniformRng;
using QuantLib::KnuthUniformRng;
using QuantLib::MersenneTwisterUniformRng;
using QuantLib::Xoshiro256StarStarUniformRng;

typedef QuantLib::PseudoRandom::urng_type UniformRandomGenerator;

using QuantLib::CLGaussianRng;
using QuantLib::BoxMullerGaussianRng;
using QuantLib::InverseCumulativeRng;

typedef QuantLib::PseudoRandom::rng_type GaussianRandomGenerator;

using QuantLib::RandomSequenceGenerator;

typedef QuantLib::PseudoRandom::ursg_type UniformRandomSequenceGenerator;
using QuantLib::SobolBrownianGenerator;

using QuantLib::HaltonRsg;
using QuantLib::SobolRsg;
using QuantLib::SobolBrownianBridgeRsg;
using QuantLib::Burley2020SobolRsg;
using QuantLib::Burley2020SobolBrownianBridgeRsg;

typedef QuantLib::LowDiscrepancy::ursg_type
    UniformLowDiscrepancySequenceGenerator;

using QuantLib::InverseCumulativeRsg;

typedef QuantLib::PseudoRandom::rsg_type GaussianRandomSequenceGenerator;
typedef QuantLib::LowDiscrepancy::rsg_type
    GaussianLowDiscrepancySequenceGenerator;

SWIGINTERN double const &Sample_Sl_Real_Sg__value(Sample< Real > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Real_Sg__weight(Sample< Real > *self){ return self->weight; }
SWIGINTERN Array const &Sample_Sl_Array_Sg__value(Sample< Array > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Array_Sg__weight(Sample< Array > *self){ return self->weight; }
SWIGINTERN std::vector< double,std::allocator< double > > const &Sample_Sl_std_vector_Sl_Real_Sg__Sg__value(Sample< std::vector< Real > > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_std_vector_Sl_Real_Sg__Sg__weight(Sample< std::vector< Real > > *self){ return self->weight; }
SWIGINTERN Real UniformRandomGenerator_nextValue(UniformRandomGenerator const *self){
			return (*self).next().value;
		}
SWIGINTERN Real GaussianRandomGenerator_nextValue(GaussianRandomGenerator const *self){
			return (*self).next().value;
		}
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > SobolRsg_nextInt32Sequence(SobolRsg *self){
          return to_vector<unsigned int>(self->nextInt32Sequence());
      }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > Burley2020SobolRsg_nextInt32Sequence(Burley2020SobolRsg *self){
          return to_vector<unsigned int>(self->nextInt32Sequence());
      }

using QuantLib::BrownianGenerator;
using QuantLib::MTBrownianGenerator;
using QuantLib::SobolBrownianGenerator;
using QuantLib::BrownianGeneratorFactory;
using QuantLib::MTBrownianGeneratorFactory;
using QuantLib::SobolBrownianGeneratorFactory;


using QuantLib::EvolutionDescription;

SWIGINTERN EvolutionDescription *new_EvolutionDescription__SWIG_0(std::vector< Time,std::allocator< Time > > const &rateTimes,std::vector< Time,std::allocator< Time > > const &evolutionTimes={},std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &relevanceRates={}){
            return new EvolutionDescription(rateTimes, evolutionTimes,
                                            to_vector<std::pair<Size, Size>>(relevanceRates));
        }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > EvolutionDescription_firstAliveRate(EvolutionDescription const *self){
            return to_vector<unsigned int>(self->firstAliveRate());
        }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > EvolutionDescription_relevanceRates(EvolutionDescription const *self){
            return to_vector<std::pair<unsigned int, unsigned int>>(self->relevanceRates());
        }


    void _checkCompatibility(const EvolutionDescription& evolution,
                             const std::vector<unsigned int>& numeraires) {
        QuantLib::checkCompatibility(evolution, to_vector<Size>(numeraires));
    }

    bool _isInTerminalMeasure(const EvolutionDescription& evolution,
                              const std::vector<unsigned int>& numeraires) {
        return QuantLib::isInTerminalMeasure(evolution, to_vector<Size>(numeraires));
    }

    bool _isInMoneyMarketPlusMeasure(const EvolutionDescription& evolution,
                                     const std::vector<unsigned int>& numeraires,
                                     Size offset = 1) {
        return QuantLib::isInMoneyMarketPlusMeasure(evolution, to_vector<Size>(numeraires), offset);
    }

    bool _isInMoneyMarketMeasure(const EvolutionDescription& evolution,
                                 const std::vector<unsigned int>& numeraires) {
        return QuantLib::isInMoneyMarketMeasure(evolution, to_vector<Size>(numeraires));
    }

    std::vector<unsigned int> _terminalMeasure(const EvolutionDescription& evolution) {
        return to_vector<unsigned int>(QuantLib::terminalMeasure(evolution));
    }

    std::vector<unsigned int> _moneyMarketPlusMeasure(const EvolutionDescription& evolution,
                                                      Size offset = 1) {
        return to_vector<unsigned int>(QuantLib::moneyMarketPlusMeasure(evolution, offset));
    }

    std::vector<unsigned int> _moneyMarketMeasure(const EvolutionDescription& evolution) {
        return to_vector<unsigned int>(QuantLib::moneyMarketMeasure(evolution));
    }



using QuantLib::MarketModel;
using QuantLib::MarketModelFactory;


using QuantLib::PiecewiseConstantCorrelation;
using QuantLib::ExponentialForwardCorrelation;


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


      namespace swig {
	template <>  struct traits<std::vector< Matrix, std::allocator< Matrix > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Matrix" "," "std::allocator< Matrix >" " >";
	  }
	};
      }
    

using QuantLib::CurveState;
using QuantLib::LMMCurveState;


using QuantLib::LMMDriftCalculator;


using QuantLib::MarketModelEvolver;
using QuantLib::LogNormalFwdRateIpc;

SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > MarketModelEvolver_numeraires(MarketModelEvolver const *self){
            return to_vector<unsigned int>(self->numeraires());
        }
SWIGINTERN LogNormalFwdRateIpc *new_LogNormalFwdRateIpc__SWIG_0(ext::shared_ptr< MarketModel > const &model,BrownianGeneratorFactory const &factory,std::vector< unsigned int,std::allocator< unsigned int > > const &numeraires,Size initialStep=0){
            return new LogNormalFwdRateIpc(model, factory,
                                           to_vector<Size>(numeraires),
                                           initialStep);
        }

using QuantLib::AbcdVol;


using QuantLib::AbcdMathFunction;
using QuantLib::AbcdFunction;


using QuantLib::ContinuousFloatingLookbackOption;
using QuantLib::ContinuousFixedLookbackOption;
using QuantLib::ContinuousPartialFloatingLookbackOption;
using QuantLib::ContinuousPartialFixedLookbackOption;


using QuantLib::AnalyticContinuousFloatingLookbackEngine;
using QuantLib::AnalyticContinuousFixedLookbackEngine;
using QuantLib::AnalyticContinuousPartialFloatingLookbackEngine;
using QuantLib::AnalyticContinuousPartialFixedLookbackEngine;


Matrix getCovariance(const Array& volatilities, const Matrix& correlations) {
    return QuantLib::getCovariance(volatilities.begin(),
                                   volatilities.end(),
                                   correlations);
}


using QuantLib::Path;

SWIGINTERN Real Path___getitem__(Path *self,Integer i){
            Integer size_ = Integer(self->length());
            if (i>=0 && i<size_) {
                return (*self)[i];
            } else if (i<0 && -i<=size_) {
                return (*self)[size_+i];
            } else {
                throw std::out_of_range("path index out of range");
            }
        }
SWIGINTERN Path const &Sample_Sl_Path_Sg__value(Sample< Path > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_Path_Sg__weight(Sample< Path > *self){ return self->weight; }

using QuantLib::PathGenerator;


using QuantLib::MultiPath;

SWIGINTERN Path const &MultiPath___getitem__(MultiPath *self,Integer i){
            Integer assets_ = Integer(self->assetNumber());
            if (i>=0 && i<assets_) {
                return (*self)[i];
            } else if (i<0 && -i<=assets_) {
                return (*self)[assets_+i];
            } else {
                throw std::out_of_range("multi-path index out of range");
            }
        }
SWIGINTERN MultiPath const &Sample_Sl_MultiPath_Sg__value(Sample< MultiPath > *self){ return self->value; }
SWIGINTERN Real Sample_Sl_MultiPath_Sg__weight(Sample< MultiPath > *self){ return self->weight; }

using QuantLib::MultiPathGenerator;

SWIGINTERN MultiPathGenerator< GaussianRandomSequenceGenerator > *new_MultiPathGenerator_Sl_GaussianRandomSequenceGenerator_Sg___SWIG_2(ext::shared_ptr< StochasticProcess > const &process,std::vector< Time,std::allocator< Time > > const &times,GaussianRandomSequenceGenerator const &generator,bool brownianBridge=false){
          return new MultiPathGenerator<GaussianRandomSequenceGenerator>(process,
                                             TimeGrid(
                                                 times.begin(),
                                                 times.end()),
                                             generator,
                                             brownianBridge);
      }
SWIGINTERN MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *new_MultiPathGenerator_Sl_GaussianLowDiscrepancySequenceGenerator_Sg___SWIG_2(ext::shared_ptr< StochasticProcess > const &process,std::vector< Time,std::allocator< Time > > const &times,GaussianLowDiscrepancySequenceGenerator const &generator,bool brownianBridge=false){
          return new MultiPathGenerator<GaussianLowDiscrepancySequenceGenerator>(process,
                                             TimeGrid(
                                                 times.begin(),
                                                 times.end()),
                                             generator,
                                             brownianBridge);
      }

using QuantLib::BrownianBridge;

SWIGINTERN std::vector< Real,std::allocator< Real > > BrownianBridge_transform(BrownianBridge *self,std::vector< Real,std::allocator< Real > > const &input){
      std::vector<Real> outp(input.size());
      self->transform(input.begin(),input.end(),outp.begin());
      return outp;
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > BrownianBridge_bridgeIndex(BrownianBridge const *self){
        return to_vector<unsigned int>(self->bridgeIndex());
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > BrownianBridge_leftIndex(BrownianBridge const *self){
        return to_vector<unsigned int>(self->leftIndex());
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > BrownianBridge_rightIndex(BrownianBridge const *self){
        return to_vector<unsigned int>(self->rightIndex());
    }

class OdeFct {
  public:
    OdeFct(PyObject* function) : function_(function) {
        Py_XINCREF(function_);
    }
    OdeFct(const OdeFct& f)
    : function_(f.function_) {
        Py_XINCREF(function_);
    }
    OdeFct& operator=(const OdeFct& f) {
        if ((this != &f) && (function_ != f.function_)) {
            Py_XDECREF(function_);
            function_ = f.function_;
            Py_XINCREF(function_);
        }
        return *this;
    }
    ~OdeFct() {
        Py_XDECREF(function_);
    }
    
    const std::vector<Real> operator()(Real x, const std::vector<Real>& y) const {
        PyObject* pyY = PyList_New(y.size());
        for (Size i=0; i < y.size(); ++i)
            PyList_SetItem(pyY, i, PyFloat_FromDouble(y[i]));
        
        PyObject* pyResult = PyObject_CallFunction(function_,"dO",x, pyY);
        
        Py_XDECREF(pyY);

        QL_ENSURE(pyResult != NULL && PyList_Check(pyResult), 
            "failed to call Python function");
       
           std::vector<Real> retVal(y.size());
           for (Size i=0; i < y.size(); ++i)
               retVal[i] = PyFloat_AsDouble(PyList_GET_ITEM(pyResult, i));
                          
        Py_XDECREF(pyResult);
        
        return retVal;
    }
  private:
    PyObject* function_;
};


using QuantLib::AdaptiveRungeKutta;

SWIGINTERN double AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_0(AdaptiveRungeKutta< Real > *self,PyObject *fct,double y1,Real x1,Real x2){
            BinaryFunction f(fct);
            return self->operator()(f, y1, x1, x2);
        }
SWIGINTERN std::vector< double,std::allocator< double > > AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_1(AdaptiveRungeKutta< Real > *self,PyObject *fct,std::vector< double,std::allocator< double > > const &y1,Real x1,Real x2){
            OdeFct f(fct);
            return self->operator()(f, y1, x1, x2);
        }

typedef QuantLib::BoundaryCondition<QuantLib::TridiagonalOperator>
        DefaultBoundaryCondition;


using QuantLib::NeumannBC;
using QuantLib::DirichletBC;


using QuantLib::TridiagonalOperator;

SWIGINTERN TridiagonalOperator TridiagonalOperator___add__(TridiagonalOperator *self,TridiagonalOperator const &O){
            return *self+O;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___sub__(TridiagonalOperator *self,TridiagonalOperator const &O){
            return *self-O;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___mul__(TridiagonalOperator *self,Real a){
            return *self*a;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___div__(TridiagonalOperator *self,Real a){
            return *self/a;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___iadd__(TridiagonalOperator *self,TridiagonalOperator const &O){
            return *self+O;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___isub__(TridiagonalOperator *self,TridiagonalOperator const &O){
            return *self-O;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___imul__(TridiagonalOperator *self,Real a){
            return *self*a;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___rmul__(TridiagonalOperator *self,Real a){
            return *self*a;
        }
SWIGINTERN TridiagonalOperator TridiagonalOperator___idiv__(TridiagonalOperator *self,Real a){
            return *self/a;
        }

using QuantLib::DPlus;
using QuantLib::DMinus;
using QuantLib::DZero;
using QuantLib::DPlusDMinus;


using QuantLib::HestonSLVProcess;


using QuantLib::HestonSLVMCModel;

SWIGINTERN HestonSLVMCModel *new_HestonSLVMCModel__SWIG_0(ext::shared_ptr< LocalVolTermStructure > const &localVol,ext::shared_ptr< HestonModel > const &model,ext::shared_ptr< BrownianGeneratorFactory > const &brownianGeneratorFactory,Date const &endDate,Size timeStepsPerYear=365,Size nBins=201,Size calibrationPaths=(1 << 15),std::vector< Date,std::allocator< Date > > const &mandatoryDates=std::vector< Date >(),Real mixingFactor=1.0){
            return new HestonSLVMCModel(
                Handle<LocalVolTermStructure>(localVol), Handle<HestonModel>(model),
                brownianGeneratorFactory, endDate, timeStepsPerYear,
                nBins, calibrationPaths, mandatoryDates, mixingFactor);
        }

using QuantLib::FdmHestonGreensFct;
using QuantLib::HestonSLVFDMModel;
using QuantLib::HestonSLVFokkerPlanckFdmParams;

SWIGINTERN HestonSLVFokkerPlanckFdmParams *new_HestonSLVFokkerPlanckFdmParams(Size xGrid,Size vGrid,Size tMaxStepsPerYear,Size tMinStepsPerYear,Real tStepNumberDecay,Size nRannacherTimeSteps,Size predictionCorretionSteps,Real x0Density,Real localVolEpsProb,Size maxIntegrationIterations,Real vLowerEps,Real vUpperEps,Real vMin,Real v0Density,Real vLowerBoundDensity,Real vUpperBoundDensity,Real leverageFctPropEps,FdmHestonGreensFct::Algorithm greensAlgorithm,FdmSquareRootFwdOp::TransformationType trafoType,FdmSchemeDesc schemeDesc){
            
                const HestonSLVFokkerPlanckFdmParams params = {
                    xGrid, vGrid,
                    tMaxStepsPerYear, tMinStepsPerYear,
                    tStepNumberDecay,
                    nRannacherTimeSteps,
                    predictionCorretionSteps,
                    x0Density,
                    localVolEpsProb,
                    maxIntegrationIterations,
                    vLowerEps, vUpperEps, vMin,
                    v0Density, vLowerBoundDensity, vUpperBoundDensity,
                    leverageFctPropEps,
                    greensAlgorithm,
                    trafoType,
                    schemeDesc };

                return new HestonSLVFokkerPlanckFdmParams(params);
        }
SWIGINTERN HestonSLVFDMModel *new_HestonSLVFDMModel__SWIG_0(ext::shared_ptr< LocalVolTermStructure > const &localVol,ext::shared_ptr< HestonModel > const &model,Date const &endDate,HestonSLVFokkerPlanckFdmParams const &params,bool const logging=false,std::vector< Date,std::allocator< Date > > const &mandatoryDates=std::vector< Date >(),Real mixingFactor=1.0){
            return new HestonSLVFDMModel(
                Handle<LocalVolTermStructure>(localVol), Handle<HestonModel>(model),
                endDate, params, logging, mandatoryDates, mixingFactor);
        }

using QuantLib::SpreadOption;
using QuantLib::KirkSpreadOptionEngine;


using QuantLib::Statistics;
using QuantLib::IncrementalStatistics;
using QuantLib::RiskStatistics;
using QuantLib::GenericSequenceStatistics;

SWIGINTERN void Statistics_add__SWIG_2(Statistics *self,std::vector< Real,std::allocator< Real > > const &values){
            self->addSequence(values.begin(), values.end());
        }
SWIGINTERN void Statistics_add__SWIG_3(Statistics *self,std::vector< Real,std::allocator< Real > > const &values,std::vector< Real,std::allocator< Real > > const &weights){
            self->addSequence(values.begin(), values.end(), weights.begin());
        }
SWIGINTERN void IncrementalStatistics_add__SWIG_2(IncrementalStatistics *self,std::vector< Real,std::allocator< Real > > const &values){
            self->addSequence(values.begin(), values.end());
        }
SWIGINTERN void IncrementalStatistics_add__SWIG_3(IncrementalStatistics *self,std::vector< Real,std::allocator< Real > > const &values,std::vector< Real,std::allocator< Real > > const &weights){
            self->addSequence(values.begin(), values.end(), weights.begin());
        }

using QuantLib::CapFloorTermVolatilityStructure;

SWIGINTERN bool Handle_Sl_CapFloorTermVolatilityStructure_Sg____nonzero__(Handle< CapFloorTermVolatilityStructure > *self){
            return !self->empty();
        }
SWIGINTERN bool Handle_Sl_CapFloorTermVolatilityStructure_Sg____bool__(Handle< CapFloorTermVolatilityStructure > *self){
            return !self->empty();
        }
SWIGINTERN ext::shared_ptr< Observable > Handle_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(Handle< CapFloorTermVolatilityStructure > *self){
        return ext::shared_ptr<Observable>(*self);
    }
SWIGINTERN void RelinkableHandle_Sl_CapFloorTermVolatilityStructure_Sg__reset(RelinkableHandle< CapFloorTermVolatilityStructure > *self){
            self->linkTo(ext::shared_ptr<CapFloorTermVolatilityStructure>());
        }

using QuantLib::CapFloorTermVolCurve;


using QuantLib::CapFloorTermVolSurface;


using QuantLib::StrippedOptionletBase;
using QuantLib::VolatilityType;


using QuantLib::StrippedOptionlet;


using QuantLib::OptionletStripper1;


using QuantLib::StrippedOptionletAdapter;


using QuantLib::Actual365Fixed;
using QuantLib::Swaption;
using QuantLib::NonstandardSwaption;
using QuantLib::Settlement;
using QuantLib::FloatFloatSwaption;

SWIGINTERN Real Swaption_vega(Swaption *self){
            return self->result<Real>("vega");
        }
SWIGINTERN Real Swaption_delta(Swaption *self){
            return self->result<Real>("delta");
        }
SWIGINTERN Real Swaption_annuity(Swaption *self){
            return self->result<Real>("annuity");
        }

using QuantLib::BasketGeneratingEngine;

SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > NonstandardSwaption_calibrationBasket(NonstandardSwaption *self,ext::shared_ptr< SwapIndex > swapIndex,ext::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility,std::string typeStr){

            BasketGeneratingEngine::CalibrationBasketType type;
            if(typeStr == "Naive")
                type = BasketGeneratingEngine::Naive;
            else if(typeStr == "MaturityStrikeByDeltaGamma")
                type = BasketGeneratingEngine::MaturityStrikeByDeltaGamma;
            else
                QL_FAIL("type " << typeStr << "unknown.");

            std::vector<ext::shared_ptr<BlackCalibrationHelper> > hs =
                self->calibrationBasket(swapIndex, swaptionVolatility, type);
            std::vector<ext::shared_ptr<BlackCalibrationHelper> > helpers(hs.size());
            for (Size i=0; i<hs.size(); ++i)
                helpers[i] = hs[i];
            return helpers;
        }
SWIGINTERN std::vector< Real,std::allocator< Real > > NonstandardSwaption_probabilities(NonstandardSwaption *self){
            return self->result<std::vector<Real> >("probabilities");
        }
SWIGINTERN std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > FloatFloatSwaption_calibrationBasket(FloatFloatSwaption *self,ext::shared_ptr< SwapIndex > swapIndex,ext::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility,std::string typeStr){

        BasketGeneratingEngine::CalibrationBasketType type;
        if(typeStr == "Naive")
            type = BasketGeneratingEngine::Naive;
        else if(typeStr == "MaturityStrikeByDeltaGamma")
            type = BasketGeneratingEngine::MaturityStrikeByDeltaGamma;
        else
            QL_FAIL("type " << typeStr << "unknown.");

        std::vector<ext::shared_ptr<BlackCalibrationHelper> > hs =
            self->calibrationBasket(swapIndex, swaptionVolatility, type);
        std::vector<ext::shared_ptr<BlackCalibrationHelper> > helpers(hs.size());
        for (Size i=0; i<hs.size(); ++i)
            helpers[i] = hs[i];
        return helpers;
        }
SWIGINTERN Real FloatFloatSwaption_underlyingValue(FloatFloatSwaption *self){
            return self->result<Real>("underlyingValue");
        }
SWIGINTERN std::vector< Real,std::allocator< Real > > FloatFloatSwaption_probabilities(FloatFloatSwaption *self){
            return self->result<std::vector<Real> >("probabilities");
        }

using QuantLib::BlackSwaptionEngine;
using QuantLib::BachelierSwaptionEngine;


using QuantLib::VanillaSwingOption;


using QuantLib::FdSimpleBSSwingEngine;
using QuantLib::FdSimpleExtOUJumpSwingEngine;

SWIGINTERN FdSimpleExtOUJumpSwingEngine *new_FdSimpleExtOUJumpSwingEngine__SWIG_0(ext::shared_ptr< ExtOUWithJumpsProcess > const &process,ext::shared_ptr< YieldTermStructure > const &rTS,Size tGrid=50,Size xGrid=200,Size yGrid=50,std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &shape=std::vector< std::pair< Time,Real > >(),FdmSchemeDesc const &schemeDesc=FdmSchemeDesc::Hundsdorfer()){

            ext::shared_ptr<FdSimpleExtOUJumpSwingEngine::Shape> curve(
                              new FdSimpleExtOUJumpSwingEngine::Shape(shape));

            return new FdSimpleExtOUJumpSwingEngine(
                    process, rTS, tGrid, xGrid, yGrid,
                    curve, schemeDesc);
        }


void enableTracing() { 
    QL_TRACE_ENABLE;
}

void disableTracing() {
    QL_TRACE_DISABLE;
}



using QuantLib::ConstantEstimator;
using QuantLib::SimpleLocalEstimator;
using QuantLib::GarmanKlassSigma1;
using QuantLib::ParkinsonSigma;
using QuantLib::GarmanKlassSigma3;
using QuantLib::GarmanKlassSigma4;
using QuantLib::GarmanKlassSigma5;
using QuantLib::GarmanKlassSigma6;


using QuantLib::InterpolatedZeroCurve;

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN int Swig_var___hexversion___set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable __hexversion__ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var___hexversion___get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(__hexversion__));
  return pyobj;
}


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


SWIGINTERN PyObject *Swig_var___version___get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(__version__);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      try {
        result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)(arg1)->incr();
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)(arg1)->decr();
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      try {
        result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
      } catch(std::invalid_argument &_e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      try {
        result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
      } catch(std::invalid_argument &_e) {
        SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      try {
        result = (PyObject *)(arg1)->next();
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      try {
        result = (PyObject *)(arg1)->__next__();
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      try {
        result = (PyObject *)(arg1)->previous();
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      try {
        result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
      } catch(swig::stop_iteration &_e) {
        {
          (void)_e;
          SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
          SWIG_fail;
        }
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


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

SWIGINTERN PyObject *_wrap_new_Period__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Period *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Period *)new Period();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Period__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  TimeUnit arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Period *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Period" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Period" "', argument " "2"" of type '" "TimeUnit""'");
  } 
  arg2 = static_cast< TimeUnit >(val2);
  {
    try {
      result = (Period *)new Period(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Period__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Frequency arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Period *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Period" "', argument " "1"" of type '" "Frequency""'");
  } 
  arg1 = static_cast< Frequency >(val1);
  {
    try {
      result = (Period *)new Period(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Period_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period_length" "', argument " "1"" of type '" "Period const *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Integer)((Period const *)arg1)->length();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Period_units(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeUnit result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period_units" "', argument " "1"" of type '" "Period const *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (TimeUnit)((Period const *)arg1)->units();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Period_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period_frequency" "', argument " "1"" of type '" "Period const *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Frequency)((Period const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Period_normalized(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period_normalized" "', argument " "1"" of type '" "Period const *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = ((Period const *)arg1)->normalized();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Period__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Period *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Period" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Period" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (Period *)new_Period__SWIG_3((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Period(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Period", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Period__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Period__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Period__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Period__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Period'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Period::Period()\n"
    "    Period::Period(Integer,TimeUnit)\n"
    "    Period::Period(Frequency)\n"
    "    Period::Period(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Period___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___str__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = Period___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Period___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___repr__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = Period___repr__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Period___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___neg__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = Period___neg__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Period result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___add__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___add__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___add__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = Period___add__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Period result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___sub__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___sub__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___sub__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = Period___sub__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Period result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___mul__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Period___mul__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = Period___mul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Period result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___rmul__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Period___rmul__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = Period___rmul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___lt__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___lt__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___lt__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (bool)Period___lt__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___gt__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___gt__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___gt__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (bool)Period___gt__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___le__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___le__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___le__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (bool)Period___le__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___ge__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___ge__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___ge__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (bool)Period___ge__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___eq__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___eq__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___eq__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (bool)Period___eq__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Period___cmp__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Period___cmp__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Period___cmp__" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Period___cmp__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Period___cmp__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (int)Period___cmp__(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Period(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = (Period *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Period, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Period" "', argument " "1"" of type '" "Period *""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_PeriodVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_iterator" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_Period_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___nonzero__" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Period_Sg____nonzero__((std::vector< Period > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___bool__" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Period_Sg____bool__((std::vector< Period > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___len__" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = std_vector_Sl_Period_Sg____len__((std::vector< Period > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  std::vector< Period >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___getslice__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___getslice__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PeriodVector___getslice__" "', argument " "3"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Period >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< Period,std::allocator< Period > > *)std_vector_Sl_Period_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  std::vector< Period >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___setslice__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___setslice__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PeriodVector___setslice__" "', argument " "3"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Period >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Period_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  std::vector< Period >::difference_type arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___setslice__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___setslice__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PeriodVector___setslice__" "', argument " "3"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Period >::difference_type >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PeriodVector___setslice__" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector___setslice__" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Period_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< Period,std::allocator< Period > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PeriodVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PeriodVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PeriodVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PeriodVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Period >::__setslice__(std::vector< Period >::difference_type,std::vector< Period >::difference_type)\n"
    "    std::vector< Period >::__setslice__(std::vector< Period >::difference_type,std::vector< Period >::difference_type,std::vector< Period,std::allocator< Period > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  std::vector< Period >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___delslice__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___delslice__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PeriodVector___delslice__" "', argument " "3"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Period >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Period_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___delitem__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___delitem__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_Period_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___getitem__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< Period,std::allocator< Period > > *)std_vector_Sl_Period_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___setitem__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PeriodVector___setitem__" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector___setitem__" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Period_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___setitem__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Period_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___delitem__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Period_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_PeriodVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< Period >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___getitem__" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___getitem__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< Period >::value_type *) &std_vector_Sl_Period_Sg____getitem____SWIG_1((std::vector< Period > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Period >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_PeriodVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::difference_type arg2 ;
  std::vector< Period >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector___setitem__" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector___setitem__" "', argument " "2"" of type '" "std::vector< Period >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PeriodVector___setitem__" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector___setitem__" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Period >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_Period_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(Period const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PeriodVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_PeriodVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PeriodVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PeriodVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PeriodVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Period >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Period,std::allocator< Period > > const &)\n"
    "    std::vector< Period >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Period >::__setitem__(std::vector< Period >::difference_type,std::vector< Period >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_pop" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_Period_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Period >::value_type(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_append" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PeriodVector_append" "', argument " "2"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_append" "', argument " "2"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Period >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_Period_Sg__append(arg1,(Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeriodVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< Period > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< Period > *)new std::vector< Period >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeriodVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< Period > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PeriodVector" "', argument " "1"" of type '" "std::vector< Period > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PeriodVector" "', argument " "1"" of type '" "std::vector< Period > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< Period > *)new std::vector< Period >((std::vector< Period > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_empty" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (bool)((std::vector< Period > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_size" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = ((std::vector< Period > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_swap" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PeriodVector_swap" "', argument " "2"" of type '" "std::vector< Period > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_swap" "', argument " "2"" of type '" "std::vector< Period > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Period > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_begin" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_end" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_rbegin" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_rend" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_clear" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< Period > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_get_allocator" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = ((std::vector< Period > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Period >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_Period_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeriodVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< Period > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PeriodVector" "', argument " "1"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Period >::size_type >(val1);
  {
    try {
      result = (std::vector< Period > *)new std::vector< Period >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_pop_back" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_resize" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector_resize" "', argument " "2"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< Period >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_erase" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_erase" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Period >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_erase" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Period_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::iterator arg2 ;
  std::vector< Period >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< Period >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_erase" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_erase" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Period >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_erase" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_erase" "', argument " "3"" of type '" "std::vector< Period >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Period >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_erase" "', argument " "3"" of type '" "std::vector< Period >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Period_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PeriodVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_PeriodVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_PeriodVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PeriodVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Period >::erase(std::vector< Period >::iterator)\n"
    "    std::vector< Period >::erase(std::vector< Period >::iterator,std::vector< Period >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_PeriodVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period >::size_type arg1 ;
  std::vector< Period >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< Period > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PeriodVector" "', argument " "1"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Period >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PeriodVector" "', argument " "2"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PeriodVector" "', argument " "2"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Period >::value_type * >(argp2);
  {
    try {
      result = (std::vector< Period > *)new std::vector< Period >(arg1,(std::vector< Period >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeriodVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PeriodVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PeriodVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PeriodVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PeriodVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PeriodVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PeriodVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Period >::vector()\n"
    "    std::vector< Period >::vector(std::vector< Period > const &)\n"
    "    std::vector< Period >::vector(std::vector< Period >::size_type)\n"
    "    std::vector< Period >::vector(std::vector< Period >::size_type,std::vector< Period >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_push_back" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PeriodVector_push_back" "', argument " "2"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_push_back" "', argument " "2"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Period >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< Period >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_front" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (std::vector< Period >::value_type *) &((std::vector< Period > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Period >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_back" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = (std::vector< Period >::value_type *) &((std::vector< Period > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Period >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type arg2 ;
  std::vector< Period >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_assign" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector_assign" "', argument " "2"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PeriodVector_assign" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_assign" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Period >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< Period >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type arg2 ;
  std::vector< Period >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_resize" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector_resize" "', argument " "2"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PeriodVector_resize" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_resize" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Period >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< Period >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PeriodVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PeriodVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PeriodVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PeriodVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Period >::resize(std::vector< Period >::size_type)\n"
    "    std::vector< Period >::resize(std::vector< Period >::size_type,std::vector< Period >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::iterator arg2 ;
  std::vector< Period >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< Period >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_insert" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_insert" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Period >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_insert" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PeriodVector_insert" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_insert" "', argument " "3"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Period >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_Period_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Period >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::iterator arg2 ;
  std::vector< Period >::size_type arg3 ;
  std::vector< Period >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_insert" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_insert" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Period >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PeriodVector_insert" "', argument " "2"" of type '" "std::vector< Period >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PeriodVector_insert" "', argument " "3"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Period >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PeriodVector_insert" "', argument " "4"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodVector_insert" "', argument " "4"" of type '" "std::vector< Period >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Period >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_Period_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PeriodVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PeriodVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Period,std::allocator< Period > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Period >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PeriodVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PeriodVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Period >::insert(std::vector< Period >::iterator,std::vector< Period >::value_type const &)\n"
    "    std::vector< Period >::insert(std::vector< Period >::iterator,std::vector< Period >::size_type,std::vector< Period >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PeriodVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  std::vector< Period >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PeriodVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_reserve" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PeriodVector_reserve" "', argument " "2"" of type '" "std::vector< Period >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Period >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PeriodVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodVector_capacity" "', argument " "1"" of type '" "std::vector< Period > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      result = ((std::vector< Period > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PeriodVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period > *arg1 = (std::vector< Period > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Period_std__allocatorT_Period_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PeriodVector" "', argument " "1"" of type '" "std::vector< Period > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Period > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Date__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Date *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Date *)new Date();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "Day""'");
  } 
  arg1 = static_cast< Day >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  {
    try {
      result = (Date *)new Date(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Hour arg4 ;
  Minute arg5 ;
  Second arg6 ;
  Millisecond arg7 ;
  Microsecond arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "Day""'");
  } 
  arg1 = static_cast< Day >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "Hour""'");
  } 
  arg4 = static_cast< Hour >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "Minute""'");
  } 
  arg5 = static_cast< Minute >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "Second""'");
  } 
  arg6 = static_cast< Second >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Date" "', argument " "7"" of type '" "Millisecond""'");
  } 
  arg7 = static_cast< Millisecond >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Date" "', argument " "8"" of type '" "Microsecond""'");
  } 
  arg8 = static_cast< Microsecond >(val8);
  {
    try {
      result = (Date *)new_Date__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Hour arg4 ;
  Minute arg5 ;
  Second arg6 ;
  Millisecond arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "Day""'");
  } 
  arg1 = static_cast< Day >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "Hour""'");
  } 
  arg4 = static_cast< Hour >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "Minute""'");
  } 
  arg5 = static_cast< Minute >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "Second""'");
  } 
  arg6 = static_cast< Second >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Date" "', argument " "7"" of type '" "Millisecond""'");
  } 
  arg7 = static_cast< Millisecond >(val7);
  {
    try {
      result = (Date *)new_Date__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Day arg1 ;
  Month arg2 ;
  Year arg3 ;
  Hour arg4 ;
  Minute arg5 ;
  Second arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "Day""'");
  } 
  arg1 = static_cast< Day >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Date" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Date" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Date" "', argument " "4"" of type '" "Hour""'");
  } 
  arg4 = static_cast< Hour >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Date" "', argument " "5"" of type '" "Minute""'");
  } 
  arg5 = static_cast< Minute >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Date" "', argument " "6"" of type '" "Second""'");
  } 
  arg6 = static_cast< Second >(val6);
  {
    try {
      result = (Date *)new_Date__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BigInteger arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  Date *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Date" "', argument " "1"" of type '" "BigInteger""'");
  } 
  arg1 = static_cast< BigInteger >(val1);
  {
    try {
      result = (Date *)new Date(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_weekday(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Weekday result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_weekday" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Weekday)((Date const *)arg1)->weekday();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_dayOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Day result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_dayOfMonth" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Day)((Date const *)arg1)->dayOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_dayOfYear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Day result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_dayOfYear" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Day)((Date const *)arg1)->dayOfYear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_month(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Month result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_month" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Month)((Date const *)arg1)->month();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_year(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Year result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_year" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Year)((Date const *)arg1)->year();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_hours(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Hour result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_hours" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Hour)Date_hours(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_minutes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Minute result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_minutes" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Minute)Date_minutes(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_seconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Second result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_seconds" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Second)Date_seconds(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_milliseconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Millisecond result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_milliseconds" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Millisecond)Date_milliseconds(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_microseconds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Microsecond result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_microseconds" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Microsecond)Date_microseconds(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_fractionOfDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_fractionOfDay" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Time)Date_fractionOfDay((Date const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_fractionOfSecond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_fractionOfSecond" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Time)Date_fractionOfSecond((Date const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_serialNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BigInteger result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_serialNumber" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (BigInteger)((Date const *)arg1)->serialNumber();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_isLeap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Year arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Date_isLeap" "', argument " "1"" of type '" "Year""'");
  } 
  arg1 = static_cast< Year >(val1);
  {
    try {
      result = (bool)Date::isLeap(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_minDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_minDate", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = Date::minDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_maxDate", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = Date::maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_todaysDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_todaysDate", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = Date::todaysDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_localDateTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_localDateTime", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = Date_localDateTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_universalDateTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_universalDateTime", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = Date_universalDateTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_endOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_endOfMonth" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date_endOfMonth" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = Date::endOfMonth((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_isEndOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_isEndOfMonth" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date_isEndOfMonth" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (bool)Date::isEndOfMonth((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_nextWeekday(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Weekday arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_nextWeekday", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_nextWeekday" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date_nextWeekday" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_nextWeekday" "', argument " "2"" of type '" "Weekday""'");
  } 
  arg2 = static_cast< Weekday >(val2);
  {
    try {
      result = Date::nextWeekday((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_nthWeekday(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Weekday arg2 ;
  Month arg3 ;
  Year arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date_nthWeekday", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Date_nthWeekday" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date_nthWeekday" "', argument " "2"" of type '" "Weekday""'");
  } 
  arg2 = static_cast< Weekday >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Date_nthWeekday" "', argument " "3"" of type '" "Month""'");
  } 
  arg3 = static_cast< Month >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Date_nthWeekday" "', argument " "4"" of type '" "Year""'");
  } 
  arg4 = static_cast< Year >(val4);
  {
    try {
      result = Date::nthWeekday(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___add____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  BigInteger arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___add__" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date___add__" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  {
    try {
      result = ((Date const *)arg1)->operator +(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  BigInteger arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___sub__" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Date___sub__" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  {
    try {
      result = ((Date const *)arg1)->operator -(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___add____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___add__" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___add__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___add__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = ((Date const *)arg1)->operator +((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___add__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Date___add__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Date, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Date___add____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Date, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Date___add____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___sub__" "', argument " "1"" of type '" "Date const *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___sub__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___sub__" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = ((Date const *)arg1)->operator -((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_Date__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  int res1 = SWIG_OLDOBJ ;
  Date *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Date" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (Date *)new_Date__SWIG_6((std::string const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Date(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Date", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Date__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Date__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Date__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Date__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Date__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Date__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Date__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Date'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Date::Date()\n"
    "    Date::Date(Day,Month,Year)\n"
    "    Date::Date(Day,Month,Year,Hour,Minute,Second,Millisecond,Microsecond)\n"
    "    Date::Date(Day,Month,Year,Hour,Minute,Second,Millisecond)\n"
    "    Date::Date(Day,Month,Year,Hour,Minute,Second)\n"
    "    Date::Date(BigInteger)\n"
    "    Date::Date(std::string const &,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Date_weekdayNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_weekdayNumber" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (Integer)Date_weekdayNumber(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___str__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = Date___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___repr__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = Date___repr__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date_ISO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date_ISO" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = Date_ISO(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___sub____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BigInteger result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___sub__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___sub__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___sub__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (BigInteger)Date_operator_Ss___SWIG_2(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Date___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Date, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Date___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Date, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Date___sub____SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Date, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Date___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___eq__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___eq__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___eq__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)Date___eq__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___cmp__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___cmp__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___cmp__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___cmp__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___cmp__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (int)Date___cmp__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___nonzero__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (bool)Date___nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___bool__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (bool)Date___bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___hash__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___hash__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (int)Date___hash__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Date___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___lt__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___lt__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___lt__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)Date___lt__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___gt__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___gt__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___gt__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)Date___gt__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___le__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___le__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___le__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)Date___le__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___ge__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___ge__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___ge__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)Date___ge__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Date___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Date___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Date___ne__" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Date___ne__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Date___ne__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)Date___ne__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_Date(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Date, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Date" "', argument " "1"" of type '" "Date *""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_DateParser_parseFormatted(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "DateParser_parseFormatted", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateParser_parseFormatted" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateParser_parseFormatted" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateParser_parseFormatted" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateParser_parseFormatted" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = DateParser::parseFormatted((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateParser_parseISO(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateParser_parseISO" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateParser_parseISO" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = DateParser::parseISO((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateParser_parse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string arg2 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "DateParser_parse", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateParser_parse" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateParser_parse" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "DateParser_parse" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = DateParser_parse((std::string const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateParser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DateParser *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DateParser", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (DateParser *)new DateParser();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DateParser, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DateParser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DateParser *arg1 = (DateParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DateParser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateParser" "', argument " "1"" of type '" "DateParser *""'"); 
  }
  arg1 = reinterpret_cast< DateParser * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_PeriodParser_parse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PeriodParser_parse" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PeriodParser_parse" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = PeriodParser::parse((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeriodParser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PeriodParser *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PeriodParser", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (PeriodParser *)new PeriodParser();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PeriodParser, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PeriodParser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PeriodParser *arg1 = (PeriodParser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PeriodParser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PeriodParser" "', argument " "1"" of type '" "PeriodParser *""'"); 
  }
  arg1 = reinterpret_cast< PeriodParser * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_DateVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_iterator" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_Date_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___nonzero__" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Date_Sg____nonzero__((std::vector< Date > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___bool__" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Date_Sg____bool__((std::vector< Date > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___len__" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = std_vector_Sl_Date_Sg____len__((std::vector< Date > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  std::vector< Date >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___getslice__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___getslice__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateVector___getslice__" "', argument " "3"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Date >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< Date,std::allocator< Date > > *)std_vector_Sl_Date_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  std::vector< Date >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___setslice__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___setslice__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateVector___setslice__" "', argument " "3"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Date >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Date_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  std::vector< Date >::difference_type arg3 ;
  std::vector< Date,std::allocator< Date > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___setslice__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___setslice__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateVector___setslice__" "', argument " "3"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Date >::difference_type >(val3);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateVector___setslice__" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector___setslice__" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Date_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< Date,std::allocator< Date > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DateVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Date,std::allocator< Date > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DateVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Date >::__setslice__(std::vector< Date >::difference_type,std::vector< Date >::difference_type)\n"
    "    std::vector< Date >::__setslice__(std::vector< Date >::difference_type,std::vector< Date >::difference_type,std::vector< Date,std::allocator< Date > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  std::vector< Date >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___delslice__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___delslice__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateVector___delslice__" "', argument " "3"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Date >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Date_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___delitem__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___delitem__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_Date_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___getitem__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< Date,std::allocator< Date > > *)std_vector_Sl_Date_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___setitem__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateVector___setitem__" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector___setitem__" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Date_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___setitem__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Date_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___delitem__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Date_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DateVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< Date >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___getitem__" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___getitem__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< Date >::value_type *) &std_vector_Sl_Date_Sg____getitem____SWIG_1((std::vector< Date > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Date >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DateVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::difference_type arg2 ;
  std::vector< Date >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector___setitem__" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector___setitem__" "', argument " "2"" of type '" "std::vector< Date >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateVector___setitem__" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector___setitem__" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Date >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_Date_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(Date const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DateVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DateVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DateVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Date >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Date,std::allocator< Date > > const &)\n"
    "    std::vector< Date >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Date >::__setitem__(std::vector< Date >::difference_type,std::vector< Date >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_pop" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_Date_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Date >::value_type(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_append" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateVector_append" "', argument " "2"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_append" "', argument " "2"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Date >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_Date_Sg__append(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< Date > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< Date > *)new std::vector< Date >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< Date > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateVector" "', argument " "1"" of type '" "std::vector< Date > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateVector" "', argument " "1"" of type '" "std::vector< Date > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< Date > *)new std::vector< Date >((std::vector< Date > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_empty" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (bool)((std::vector< Date > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_size" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = ((std::vector< Date > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_swap" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateVector_swap" "', argument " "2"" of type '" "std::vector< Date > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_swap" "', argument " "2"" of type '" "std::vector< Date > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Date > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_begin" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_end" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_rbegin" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_rend" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_clear" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< Date > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_get_allocator" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = ((std::vector< Date > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Date >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_Date_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< Date > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateVector" "', argument " "1"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Date >::size_type >(val1);
  {
    try {
      result = (std::vector< Date > *)new std::vector< Date >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_pop_back" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_resize" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector_resize" "', argument " "2"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< Date >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_erase" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_erase" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_erase" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Date_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::iterator arg2 ;
  std::vector< Date >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< Date >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_erase" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_erase" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_erase" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_erase" "', argument " "3"" of type '" "std::vector< Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_erase" "', argument " "3"" of type '" "std::vector< Date >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Date_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DateVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DateVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Date >::erase(std::vector< Date >::iterator)\n"
    "    std::vector< Date >::erase(std::vector< Date >::iterator,std::vector< Date >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DateVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date >::size_type arg1 ;
  std::vector< Date >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< Date > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateVector" "', argument " "1"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Date >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateVector" "', argument " "2"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateVector" "', argument " "2"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Date >::value_type * >(argp2);
  {
    try {
      result = (std::vector< Date > *)new std::vector< Date >(arg1,(std::vector< Date >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DateVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DateVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DateVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DateVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DateVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DateVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Date >::vector()\n"
    "    std::vector< Date >::vector(std::vector< Date > const &)\n"
    "    std::vector< Date >::vector(std::vector< Date >::size_type)\n"
    "    std::vector< Date >::vector(std::vector< Date >::size_type,std::vector< Date >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_push_back" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateVector_push_back" "', argument " "2"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_push_back" "', argument " "2"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Date >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< Date >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_front" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (std::vector< Date >::value_type *) &((std::vector< Date > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Date >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_back" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = (std::vector< Date >::value_type *) &((std::vector< Date > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Date >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type arg2 ;
  std::vector< Date >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_assign" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector_assign" "', argument " "2"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateVector_assign" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_assign" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Date >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< Date >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type arg2 ;
  std::vector< Date >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_resize" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector_resize" "', argument " "2"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateVector_resize" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_resize" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Date >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< Date >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DateVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DateVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Date >::resize(std::vector< Date >::size_type)\n"
    "    std::vector< Date >::resize(std::vector< Date >::size_type,std::vector< Date >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::iterator arg2 ;
  std::vector< Date >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< Date >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_insert" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_insert" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_insert" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateVector_insert" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_insert" "', argument " "3"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Date >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_Date_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::iterator arg2 ;
  std::vector< Date >::size_type arg3 ;
  std::vector< Date >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_insert" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_insert" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DateVector_insert" "', argument " "2"" of type '" "std::vector< Date >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateVector_insert" "', argument " "3"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Date >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateVector_insert" "', argument " "4"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateVector_insert" "', argument " "4"" of type '" "std::vector< Date >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Date >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_Date_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DateVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DateVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Date >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DateVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DateVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Date >::insert(std::vector< Date >::iterator,std::vector< Date >::value_type const &)\n"
    "    std::vector< Date >::insert(std::vector< Date >::iterator,std::vector< Date >::size_type,std::vector< Date >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DateVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  std::vector< Date >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DateVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_reserve" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateVector_reserve" "', argument " "2"" of type '" "std::vector< Date >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Date >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DateVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateVector_capacity" "', argument " "1"" of type '" "std::vector< Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      result = ((std::vector< Date > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DateVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date > *arg1 = (std::vector< Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Date_std__allocatorT_Date_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateVector" "', argument " "1"" of type '" "std::vector< Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Date > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_daysBetween(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "daysBetween", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "daysBetween" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "daysBetween" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "daysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "daysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)daysBetween((Date const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_isIMMdate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_isIMMdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_isIMMdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_isIMMdate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (bool)IMM::isIMMdate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_isIMMdate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_isIMMdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_isIMMdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (bool)IMM::isIMMdate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_isIMMdate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMM_isIMMdate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_isIMMdate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IMM_isIMMdate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMM_isIMMdate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IMM::isIMMdate(Date const &,bool)\n"
    "    IMM::isIMMdate(Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMM_isIMMcode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_isIMMcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_isIMMcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_isIMMcode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (bool)IMM::isIMMcode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_isIMMcode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_isIMMcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_isIMMcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (bool)IMM::isIMMcode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_isIMMcode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMM_isIMMcode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_isIMMcode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IMM_isIMMcode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMM_isIMMcode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IMM::isIMMcode(std::string const &,bool)\n"
    "    IMM::isIMMcode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMM_code(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_code" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_code" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = IMM::code((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_date__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Date *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IMM_date" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_date" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = IMM::date((std::string const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_date__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = IMM::date((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_date(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMM_date", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_date__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IMM_date__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMM_date'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IMM::date(std::string const &,Date const &)\n"
    "    IMM::date(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_nextDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = IMM::nextDate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = IMM::nextDate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Date result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = IMM::nextDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Date result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_nextDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IMM_nextDate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextDate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = IMM::nextDate((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_nextDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = IMM::nextDate((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = IMM::nextDate((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMM_nextDate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_IMM_nextDate__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_nextDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_nextDate__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IMM_nextDate__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IMM_nextDate__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IMM_nextDate__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMM_nextDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IMM::nextDate(Date const &,bool)\n"
    "    IMM::nextDate(Date const &)\n"
    "    IMM::nextDate()\n"
    "    IMM::nextDate(std::string const &,bool,Date const &)\n"
    "    IMM::nextDate(std::string const &,bool)\n"
    "    IMM::nextDate(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_nextCode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = IMM::nextCode((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = IMM::nextCode((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::string result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = IMM::nextCode();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_nextCode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IMM_nextCode" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextCode" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = IMM::nextCode((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IMM_nextCode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = IMM::nextCode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IMM_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IMM_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = IMM::nextCode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IMM_nextCode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IMM_nextCode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_IMM_nextCode__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_nextCode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IMM_nextCode__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IMM_nextCode__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IMM_nextCode__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IMM_nextCode__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IMM_nextCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IMM::nextCode(Date const &,bool)\n"
    "    IMM::nextCode(Date const &)\n"
    "    IMM::nextCode()\n"
    "    IMM::nextCode(std::string const &,bool,Date const &)\n"
    "    IMM::nextCode(std::string const &,bool)\n"
    "    IMM::nextCode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IMM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IMM *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IMM", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (IMM *)new IMM();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IMM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IMM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IMM *arg1 = (IMM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IMM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IMM" "', argument " "1"" of type '" "IMM *""'"); 
  }
  arg1 = reinterpret_cast< IMM * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_ASX_isASXdate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_isASXdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_isASXdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_isASXdate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (bool)ASX::isASXdate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_isASXdate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_isASXdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_isASXdate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (bool)ASX::isASXdate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_isASXdate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASX_isASXdate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_isASXdate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASX_isASXdate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASX_isASXdate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASX::isASXdate(Date const &,bool)\n"
    "    ASX::isASXdate(Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASX_isASXcode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_isASXcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_isASXcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_isASXcode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (bool)ASX::isASXcode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_isASXcode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_isASXcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_isASXcode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (bool)ASX::isASXcode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_isASXcode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASX_isASXcode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_isASXcode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASX_isASXcode__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASX_isASXcode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASX::isASXcode(std::string const &,bool)\n"
    "    ASX::isASXcode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASX_code(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_code" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_code" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = ASX::code((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_date__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Date *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ASX_date" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_date" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ASX::date((std::string const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_date__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_date" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = ASX::date((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_date(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASX_date", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_date__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ASX_date__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASX_date'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASX::date(std::string const &,Date const &)\n"
    "    ASX::date(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_nextDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ASX::nextDate((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = ASX::nextDate((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Date result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = ASX::nextDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Date result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_nextDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASX_nextDate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextDate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = ASX::nextDate((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_nextDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ASX::nextDate((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextDate" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = ASX::nextDate((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASX_nextDate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_ASX_nextDate__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_nextDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_nextDate__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASX_nextDate__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASX_nextDate__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ASX_nextDate__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASX_nextDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASX::nextDate(Date const &,bool)\n"
    "    ASX::nextDate(Date const &)\n"
    "    ASX::nextDate()\n"
    "    ASX::nextDate(std::string const &,bool,Date const &)\n"
    "    ASX::nextDate(std::string const &,bool)\n"
    "    ASX::nextDate(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_nextCode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ASX::nextCode((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextCode" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = ASX::nextCode((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::string result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = ASX::nextCode();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_nextCode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ASX_nextCode" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextCode" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = ASX::nextCode((std::string const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ASX_nextCode" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ASX::nextCode((std::string const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ASX_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ASX_nextCode" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = ASX::nextCode((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ASX_nextCode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ASX_nextCode", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_ASX_nextCode__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_nextCode__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ASX_nextCode__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASX_nextCode__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ASX_nextCode__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ASX_nextCode__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ASX_nextCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ASX::nextCode(Date const &,bool)\n"
    "    ASX::nextCode(Date const &)\n"
    "    ASX::nextCode()\n"
    "    ASX::nextCode(std::string const &,bool,Date const &)\n"
    "    ASX::nextCode(std::string const &,bool)\n"
    "    ASX::nextCode(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ASX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ASX *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ASX", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ASX *)new ASX();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ASX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ASX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ASX *arg1 = (ASX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ASX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ASX" "', argument " "1"" of type '" "ASX *""'"); 
  }
  arg1 = reinterpret_cast< ASX * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_IntVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  std::vector< int,std::allocator< int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< int,std::allocator< int > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_int_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
    "    std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      try {
        result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)((std::vector< int > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_end" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  {
    try {
      result = (std::vector< int > *)new std::vector< int >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< int >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_IntVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_IntVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::erase(std::vector< int >::iterator)\n"
    "    std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  std::vector< int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  std::vector< int > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntVector" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  std::vector< int >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::size_type arg3 ;
  std::vector< int >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< int >::value_type temp4 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< int >::size_type >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntVector_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< int >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_int_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(int const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_IntVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVector" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_UnsignedIntVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_iterator" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_unsigned_SS_int_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___nonzero__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg____nonzero__((std::vector< unsigned int > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___bool__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg____bool__((std::vector< unsigned int > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___len__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg____len__((std::vector< unsigned int > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___getslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector___getslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntVector___getslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___setslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector___setslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntVector___setslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___setslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector___setslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntVector___setslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UnsignedIntVector___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntVector___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___delslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector___delslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntVector___delslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___delitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector___delitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___getitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnsignedIntVector___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntVector___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___delitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector___getitem__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector___getitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< unsigned int >::value_type *) &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1((std::vector< unsigned int > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnsignedIntVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UnsignedIntVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UnsignedIntVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UnsignedIntVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnsignedIntVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    std::vector< unsigned int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< unsigned int >::__setitem__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_append" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector_append" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__append(arg1,(unsigned int const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnsignedIntVector" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsignedIntVector" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_empty" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)((std::vector< unsigned int > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_size" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_swap" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnsignedIntVector_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntVector_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_begin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_end" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_rbegin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_rend" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_clear" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< unsigned int >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnsignedIntVector" "', argument " "1"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< unsigned int >::size_type >(val1);
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_pop_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_resize" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector_resize" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnsignedIntVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_UnsignedIntVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_UnsignedIntVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnsignedIntVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::erase(std::vector< unsigned int >::iterator)\n"
    "    std::vector< unsigned int >::erase(std::vector< unsigned int >::iterator,std::vector< unsigned int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnsignedIntVector" "', argument " "1"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< unsigned int >::size_type >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnsignedIntVector" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >(arg1,(std::vector< unsigned int >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_push_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector_push_back" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< unsigned int >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_front" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (std::vector< unsigned int >::value_type *) &((std::vector< unsigned int > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_back" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (std::vector< unsigned int >::value_type *) &((std::vector< unsigned int > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


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


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


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


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


SWIGINTERN PyObject *_wrap_UnsignedIntVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnsignedIntVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UnsignedIntVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UnsignedIntVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnsignedIntVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::insert(std::vector< unsigned int >::iterator,std::vector< unsigned int >::value_type const &)\n"
    "    std::vector< unsigned int >::insert(std::vector< unsigned int >::iterator,std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_reserve" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntVector_reserve" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntVector_capacity" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UnsignedIntVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnsignedIntVector" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_DoubleVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_iterator" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___len__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< double,std::allocator< double > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_double_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  (void)swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
    "    std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      try {
        result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_append" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_empty" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)((std::vector< double > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_size" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_end" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  {
    try {
      result = (std::vector< double > *)new std::vector< double >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DoubleVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DoubleVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::erase(std::vector< double >::iterator)\n"
    "    std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  std::vector< double >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  std::vector< double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleVector" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_push_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_front" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  (void)swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_back" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  (void)swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_assign" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  std::vector< double >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::size_type arg3 ;
  std::vector< double >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< double >::value_type temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
  } 
  arg3 = static_cast< std::vector< double >::size_type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleVector_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
  } 
  temp4 = static_cast< std::vector< double >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_double_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(double const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DoubleVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_reserve" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleVector" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_StrVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_iterator" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector< std::string > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___bool__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg____bool__((std::vector< std::string > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___len__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_string_Sg____len__((std::vector< std::string > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___getslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___getslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrVector___getslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrVector___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrVector___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StrVector___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_StrVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___delslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___delslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrVector___delslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___delitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___getitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_StrVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___getitem__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___getitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_StrVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector___setitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StrVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StrVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StrVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StrVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StrVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StrVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_append" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrVector_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrVector" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrVector" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::string > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrVector_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StrVector" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StrVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StrVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StrVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StrVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
  return 0;
}


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


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


SWIGINTERN PyObject *_wrap_StrVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrVector_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrVector_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrVector_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_StrVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StrVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StrVector_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrVector_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::string const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StrVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StrVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StrVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StrVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StrVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrVector_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrVector_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StrVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrVector" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_BoolVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_iterator" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_bool_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___nonzero__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_bool_Sg____nonzero__((std::vector< bool > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___bool__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_bool_Sg____bool__((std::vector< bool > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___len__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = std_vector_Sl_bool_Sg____len__((std::vector< bool > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___getslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___getslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector___getslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___setslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___setslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector___setslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  std::vector< bool,std::allocator< bool > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___setslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___setslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector___setslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoolVector___setslice__" "', argument " "4"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoolVector___setslice__" "', argument " "4"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< bool,std::allocator< bool > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BoolVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BoolVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BoolVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoolVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__setslice__(std::vector< bool >::difference_type,std::vector< bool >::difference_type)\n"
    "    std::vector< bool >::__setslice__(std::vector< bool >::difference_type,std::vector< bool >::difference_type,std::vector< bool,std::allocator< bool > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___delslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___delslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector___delslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bool_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___delitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___delitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_bool_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___getitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoolVector___setitem__" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoolVector___setitem__" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< bool,std::allocator< bool > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___delitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_bool_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_BoolVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< bool >::value_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___getitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___getitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg____getitem____SWIG_1(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_BoolVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector___setitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector___setitem__" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BoolVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BoolVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<bool,std::allocator< bool > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BoolVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BoolVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoolVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< bool,std::allocator< bool > > const &)\n"
    "    std::vector< bool >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< bool >::__setitem__(std::vector< bool >::difference_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_pop" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      try {
        result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_append" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector_append" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  {
    try {
      std_vector_Sl_bool_Sg__append(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< bool > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< bool > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoolVector" "', argument " "1"" of type '" "std::vector< bool > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoolVector" "', argument " "1"" of type '" "std::vector< bool > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >((std::vector< bool > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_empty" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (bool)((std::vector< bool > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_size" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = ((std::vector< bool > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_swap" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoolVector_swap" "', argument " "2"" of type '" "std::vector< bool > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoolVector_swap" "', argument " "2"" of type '" "std::vector< bool > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_begin" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_end" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_rbegin" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_rend" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_clear" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< bool > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_get_allocator" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = ((std::vector< bool > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< bool >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_bool_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< bool > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoolVector" "', argument " "1"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bool >::size_type >(val1);
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_pop_back" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_resize" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector_resize" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< bool >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_erase" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_bool_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< bool >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_erase" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_erase" "', argument " "3"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_erase" "', argument " "3"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_bool_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BoolVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_BoolVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_BoolVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoolVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::erase(std::vector< bool >::iterator)\n"
    "    std::vector< bool >::erase(std::vector< bool >::iterator,std::vector< bool >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BoolVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool >::size_type arg1 ;
  std::vector< bool >::value_type arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::vector< bool > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoolVector" "', argument " "1"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bool >::size_type >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BoolVector" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_BoolVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_push_back" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector_push_back" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  {
    try {
      (arg1)->push_back(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_front" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (std::vector< bool >::value_type)((std::vector< bool > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_back" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (std::vector< bool >::value_type)((std::vector< bool > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_assign" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector_assign" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector_assign" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      (arg1)->assign(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_resize" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector_resize" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector_resize" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BoolVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BoolVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BoolVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoolVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::resize(std::vector< bool >::size_type)\n"
    "    std::vector< bool >::resize(std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::vector< bool >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_insert" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector_insert" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      result = std_vector_Sl_bool_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::size_type arg3 ;
  std::vector< bool >::value_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_insert" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BoolVector_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BoolVector_insert" "', argument " "3"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::size_type >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BoolVector_insert" "', argument " "4"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg4 = static_cast< std::vector< bool >::value_type >(val4);
  {
    try {
      std_vector_Sl_bool_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BoolVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BoolVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BoolVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoolVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::insert(std::vector< bool >::iterator,std::vector< bool >::value_type)\n"
    "    std::vector< bool >::insert(std::vector< bool >::iterator,std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BoolVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_reserve" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolVector_reserve" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolVector_capacity" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = ((std::vector< bool > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoolVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoolVector" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_DoubleVectorVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__((std::vector< std::vector< double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__((std::vector< std::vector< double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__((std::vector< std::vector< double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVectorVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVectorVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVectorVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVectorVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< double > >::value_type *) &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1((std::vector< std::vector< double > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVectorVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< double,std::allocator< double > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVectorVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_append" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVectorVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVectorVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >((std::vector< std::vector< double,std::allocator< double > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< double > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_size" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< double > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_end" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVectorVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< double > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  std::vector< std::vector< double > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< double > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVectorVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DoubleVectorVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DoubleVectorVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVectorVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::erase(std::vector< std::vector< double > >::iterator)\n"
    "    std::vector< std::vector< double > >::erase(std::vector< std::vector< double > >::iterator,std::vector< std::vector< double > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DoubleVectorVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > >::size_type arg1 ;
  std::vector< std::vector< double > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(arg1,(std::vector< std::vector< double > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVectorVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< double > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_front" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_back" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::vector< double > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::vector< double > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoubleVectorVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< double > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  std::vector< std::vector< double > >::size_type arg3 ;
  std::vector< std::vector< double > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::size_type >(val3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< double,std::allocator< double > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVectorVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleVectorVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DoubleVectorVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVectorVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::insert(std::vector< std::vector< double > >::iterator,std::vector< std::vector< double > >::value_type const &)\n"
    "    std::vector< std::vector< double > >::insert(std::vector< std::vector< double > >::iterator,std::vector< std::vector< double > >::size_type,std::vector< std::vector< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoubleVectorVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVectorVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVectorVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVectorVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< double > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleVectorVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DoublePair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< double,double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  std::pair< double,double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoublePair" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoublePair" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< double,double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoublePair" "', argument " "1"" of type '" "std::pair< double,double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoublePair" "', argument " "1"" of type '" "std::pair< double,double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >((std::pair< double,double > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DoublePair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DoublePair__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< double,double >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DoublePair__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DoublePair__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DoublePair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< double,double >::pair()\n"
    "    std::pair< double,double >::pair(double,double)\n"
    "    std::pair< double,double >::pair(std::pair< double,double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoublePair_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePair_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_first_set" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePair_first_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePair_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_first_get" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  result = (double) ((arg1)->first);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePair_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePair_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_second_set" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePair_second_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePair_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_second_get" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  result = (double) ((arg1)->second);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoublePair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = (std::pair< double,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoublePair" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_DoublePairVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_iterator" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____nonzero__((std::vector< std::pair< double,double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___bool__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____bool__((std::vector< std::pair< double,double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___len__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____len__((std::vector< std::pair< double,double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  std::vector< std::pair< double,double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoublePairVector___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  std::vector< std::pair< double,double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoublePairVector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  std::vector< std::pair< double,double > >::difference_type arg3 ;
  std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoublePairVector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val3);
  {
    std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoublePairVector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoublePairVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  std::vector< std::pair< double,double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoublePairVector___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoublePairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoublePairVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::pair< double,double > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::pair< double,double > >::value_type *) &std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_1((std::vector< std::pair< double,double > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< double,double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoublePairVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::difference_type arg2 ;
  std::vector< std::pair< double,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::difference_type >(val2);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoublePairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::pair< double,double > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoublePairVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoublePairVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoublePairVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< double,double >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoublePairVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoublePairVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
    "    std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_pop" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_append" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoublePairVector_append" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_append" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__append(arg1,(std::pair< double,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePairVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::pair< double,double > > *)new std::vector< std::pair< double,double > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePairVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoublePairVector" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoublePairVector" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< double,double > > *)new std::vector< std::pair< double,double > >((std::vector< std::pair< double,double > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_empty" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::pair< double,double > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_size" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< double,double > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_swap" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoublePairVector_swap" "', argument " "2"" of type '" "std::vector< std::pair< double,double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_swap" "', argument " "2"" of type '" "std::vector< std::pair< double,double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_begin" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_end" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_rend" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_clear" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< double,double > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< double,double > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< double,double > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_double_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePairVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoublePairVector" "', argument " "1"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< double,double > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::pair< double,double > > *)new std::vector< std::pair< double,double > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_resize" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector_resize" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::pair< double,double > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_erase" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::iterator arg2 ;
  std::vector< std::pair< double,double > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::pair< double,double > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_erase" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_erase" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_erase" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoublePairVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DoublePairVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DoublePairVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoublePairVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< double,double > >::erase(std::vector< std::pair< double,double > >::iterator)\n"
    "    std::vector< std::pair< double,double > >::erase(std::vector< std::pair< double,double > >::iterator,std::vector< std::pair< double,double > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DoublePairVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > >::size_type arg1 ;
  std::vector< std::pair< double,double > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::pair< double,double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoublePairVector" "', argument " "1"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< double,double > >::size_type >(val1);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoublePairVector" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoublePairVector" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< double,double > > *)new std::vector< std::pair< double,double > >(arg1,(std::vector< std::pair< double,double > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoublePairVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_push_back" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoublePairVector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::pair< double,double > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_front" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< double,double > >::value_type *) &((std::vector< std::pair< double,double > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< double,double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_back" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< double,double > >::value_type *) &((std::vector< std::pair< double,double > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< double,double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type arg2 ;
  std::vector< std::pair< double,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_assign" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector_assign" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::size_type >(val2);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoublePairVector_assign" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_assign" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::pair< double,double > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type arg2 ;
  std::vector< std::pair< double,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_resize" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector_resize" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::size_type >(val2);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoublePairVector_resize" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_resize" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::pair< double,double > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_DoublePairVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::iterator arg2 ;
  std::vector< std::pair< double,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::pair< double,double > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_insert" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
    }
  }
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoublePairVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::pair< double,double > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< double,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::iterator arg2 ;
  std::vector< std::pair< double,double > >::size_type arg3 ;
  std::vector< std::pair< double,double > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_insert" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoublePairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoublePairVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< double,double > >::size_type >(val3);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoublePairVector_insert" "', argument " "4"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoublePairVector_insert" "', argument " "4"" of type '" "std::vector< std::pair< double,double > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::pair< double,double > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoublePairVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< double,double >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoublePairVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< double,double > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< double,double >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DoublePairVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoublePairVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< double,double > >::insert(std::vector< std::pair< double,double > >::iterator,std::vector< std::pair< double,double > >::value_type const &)\n"
    "    std::vector< std::pair< double,double > >::insert(std::vector< std::pair< double,double > >::iterator,std::vector< std::pair< double,double > >::size_type,std::vector< std::pair< double,double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  std::vector< std::pair< double,double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DoublePairVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_reserve" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePairVector_reserve" "', argument " "2"" of type '" "std::vector< std::pair< double,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< double,double > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePairVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< double,double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePairVector_capacity" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< double,double > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoublePairVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoublePairVector" "', argument " "1"" of type '" "std::vector< std::pair< double,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PairDoubleVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double >,std::vector< double > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< std::vector< double >,std::vector< double > > *)new std::pair< std::vector< double >,std::vector< double > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairDoubleVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::pair< std::vector< double >,std::vector< double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PairDoubleVector" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PairDoubleVector" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (std::pair< std::vector< double >,std::vector< double > > *)new std::pair< std::vector< double >,std::vector< double > >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairDoubleVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< std::vector< double >,std::vector< double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > *ptr = (std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PairDoubleVector" "', argument " "1"" of type '" "std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PairDoubleVector" "', argument " "1"" of type '" "std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< std::vector< double >,std::vector< double > > *)new std::pair< std::vector< double >,std::vector< double > >((std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairDoubleVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PairDoubleVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PairDoubleVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PairDoubleVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PairDoubleVector__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PairDoubleVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< std::vector< double >,std::vector< double > >::pair()\n"
    "    std::pair< std::vector< double >,std::vector< double > >::pair(std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > >)\n"
    "    std::pair< std::vector< double >,std::vector< double > >::pair(std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PairDoubleVector_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PairDoubleVector_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairDoubleVector_first_set" "', argument " "1"" of type '" "std::pair< std::vector< double >,std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< std::vector< double >,std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PairDoubleVector_first_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairDoubleVector_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairDoubleVector_first_get" "', argument " "1"" of type '" "std::pair< std::vector< double >,std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< std::vector< double >,std::vector< double > > * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->first);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairDoubleVector_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "PairDoubleVector_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairDoubleVector_second_set" "', argument " "1"" of type '" "std::pair< std::vector< double >,std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< std::vector< double >,std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PairDoubleVector_second_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairDoubleVector_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairDoubleVector_second_get" "', argument " "1"" of type '" "std::pair< std::vector< double >,std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< std::vector< double >,std::vector< double > > * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PairDoubleVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< std::vector< double >,std::vector< double > > *arg1 = (std::pair< std::vector< double >,std::vector< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_std__vectorT_double_std__allocatorT_double_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PairDoubleVector" "', argument " "1"" of type '" "std::pair< std::vector< double >,std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< std::vector< double >,std::vector< double > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UnsignedIntPair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnsignedIntPair" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnsignedIntPair" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnsignedIntPair" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsignedIntPair" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >((std::pair< unsigned int,unsigned int > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnsignedIntPair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UnsignedIntPair__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< unsigned int,unsigned int >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsignedIntPair__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UnsignedIntPair__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnsignedIntPair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< unsigned int,unsigned int >::pair()\n"
    "    std::pair< unsigned int,unsigned int >::pair(unsigned int,unsigned int)\n"
    "    std::pair< unsigned int,unsigned int >::pair(std::pair< unsigned int,unsigned int > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPair_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPair_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPair_first_set" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPair_first_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPair_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPair_first_get" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  result = (unsigned int) ((arg1)->first);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPair_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPair_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPair_second_set" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPair_second_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPair_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPair_second_get" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  result = (unsigned int) ((arg1)->second);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UnsignedIntPair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnsignedIntPair" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_iterator" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____nonzero__((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___bool__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____bool__((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___len__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____len__((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntPairVector___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UnsignedIntPairVector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntPairVector___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_1((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< unsigned int,unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnsignedIntPairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::pair< unsigned int,unsigned int > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UnsignedIntPairVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UnsignedIntPairVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< unsigned int,unsigned int >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UnsignedIntPairVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnsignedIntPairVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setitem__(std::vector< std::pair< unsigned int,unsigned int > >::difference_type,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_pop" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_append" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnsignedIntPairVector_append" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_append" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__append(arg1,(std::pair< unsigned int,unsigned int > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPairVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPairVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnsignedIntPairVector" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsignedIntPairVector" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >((std::vector< std::pair< unsigned int,unsigned int > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_empty" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_size" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_swap" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnsignedIntPairVector_swap" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_swap" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_begin" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_end" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_rend" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_clear" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< unsigned int,unsigned int > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< unsigned int,unsigned int > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPairVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnsignedIntPairVector" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_resize" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector_resize" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_erase" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_erase" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_erase" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_erase" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_UnsignedIntPairVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_UnsignedIntPairVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnsignedIntPairVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::erase(std::vector< std::pair< unsigned int,unsigned int > >::iterator)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::erase(std::vector< std::pair< unsigned int,unsigned int > >::iterator,std::vector< std::pair< unsigned int,unsigned int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_UnsignedIntPairVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg1 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnsignedIntPairVector" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val1);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UnsignedIntPairVector" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsignedIntPairVector" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >(arg1,(std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_push_back" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnsignedIntPairVector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_front" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< unsigned int,unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_back" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< unsigned int,unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_assign" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector_assign" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnsignedIntPairVector_assign" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_assign" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_resize" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector_resize" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnsignedIntPairVector_resize" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_resize" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_insert" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UnsignedIntPairVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::pair< unsigned int,unsigned int > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg3 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_insert" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UnsignedIntPairVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UnsignedIntPairVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val3);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UnsignedIntPairVector_insert" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnsignedIntPairVector_insert" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::pair< unsigned int,unsigned int > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< unsigned int,unsigned int >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UnsignedIntPairVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< unsigned int,unsigned int >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UnsignedIntPairVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UnsignedIntPairVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::insert(std::vector< std::pair< unsigned int,unsigned int > >::iterator,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::insert(std::vector< std::pair< unsigned int,unsigned int > >::iterator,std::vector< std::pair< unsigned int,unsigned int > >::size_type,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "UnsignedIntPairVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_reserve" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnsignedIntPairVector_reserve" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UnsignedIntPairVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnsignedIntPairVector_capacity" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UnsignedIntPairVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnsignedIntPairVector" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NodePair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< Date,double > *)new std::pair< Date,double >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_Date_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodePair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date arg1 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  std::pair< Date,double > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NodePair" "', argument " "1"" of type '" "Date""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NodePair" "', argument " "1"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NodePair" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (std::pair< Date,double > *)new std::pair< Date,double >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_Date_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodePair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< Date,double > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NodePair" "', argument " "1"" of type '" "std::pair< Date,double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NodePair" "', argument " "1"" of type '" "std::pair< Date,double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< Date,double > *)new std::pair< Date,double >((std::pair< Date,double > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_Date_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodePair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NodePair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NodePair__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< Date,double >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NodePair__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_NodePair__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NodePair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< Date,double >::pair()\n"
    "    std::pair< Date,double >::pair(Date,double)\n"
    "    std::pair< Date,double >::pair(std::pair< Date,double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NodePair_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodePair_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodePair_first_set" "', argument " "1"" of type '" "std::pair< Date,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodePair_first_set" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodePair_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodePair_first_get" "', argument " "1"" of type '" "std::pair< Date,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,double > * >(argp1);
  result = (Date *)& ((arg1)->first);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodePair_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodePair_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodePair_second_set" "', argument " "1"" of type '" "std::pair< Date,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodePair_second_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodePair_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodePair_second_get" "', argument " "1"" of type '" "std::pair< Date,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,double > * >(argp1);
  result = (double) ((arg1)->second);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NodePair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,double > *arg1 = (std::pair< Date,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NodePair" "', argument " "1"" of type '" "std::pair< Date,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_NodeVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_iterator" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____nonzero__((std::vector< std::pair< Date,double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___bool__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____bool__((std::vector< std::pair< Date,double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___len__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____len__((std::vector< std::pair< Date,double > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  std::vector< std::pair< Date,double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodeVector___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  std::vector< std::pair< Date,double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodeVector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  std::vector< std::pair< Date,double > >::difference_type arg3 ;
  std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodeVector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val3);
  {
    std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *ptr = (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodeVector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "NodeVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_NodeVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_NodeVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NodeVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< Date,double > >::__setslice__(std::vector< std::pair< Date,double > >::difference_type,std::vector< std::pair< Date,double > >::difference_type)\n"
    "    std::vector< std::pair< Date,double > >::__setslice__(std::vector< std::pair< Date,double > >::difference_type,std::vector< std::pair< Date,double > >::difference_type,std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NodeVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  std::vector< std::pair< Date,double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodeVector___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *)std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *ptr = (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodeVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_NodeVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::pair< Date,double > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::pair< Date,double > >::value_type *) &std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____getitem____SWIG_1((std::vector< std::pair< Date,double > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< Date,double > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< Date,double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_NodeVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::difference_type arg2 ;
  std::vector< std::pair< Date,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::difference_type >(val2);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodeVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::pair< Date,double > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "NodeVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_NodeVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_NodeVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< Date,double >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_NodeVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NodeVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< Date,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > const &)\n"
    "    std::vector< std::pair< Date,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::pair< Date,double > >::__setitem__(std::vector< std::pair< Date,double > >::difference_type,std::vector< std::pair< Date,double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NodeVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_pop" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< Date,double > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_append" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodeVector_append" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_append" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__append(arg1,(std::pair< Date,double > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodeVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::pair< Date,double > > *)new std::vector< std::pair< Date,double > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodeVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *ptr = (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NodeVector" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NodeVector" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< Date,double > > *)new std::vector< std::pair< Date,double > >((std::vector< std::pair< Date,double > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_empty" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::pair< Date,double > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_size" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< Date,double > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_swap" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodeVector_swap" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_swap" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_begin" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_end" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_rend" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_clear" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< Date,double > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< Date,double > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< Date,double > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_Date_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodeVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NodeVector" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::pair< Date,double > > *)new std::vector< std::pair< Date,double > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_resize" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector_resize" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::pair< Date,double > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_erase" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::iterator arg2 ;
  std::vector< std::pair< Date,double > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::pair< Date,double > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_erase" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_erase" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_erase" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_erase" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "NodeVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_NodeVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_NodeVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NodeVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< Date,double > >::erase(std::vector< std::pair< Date,double > >::iterator)\n"
    "    std::vector< std::pair< Date,double > >::erase(std::vector< std::pair< Date,double > >::iterator,std::vector< std::pair< Date,double > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_NodeVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > >::size_type arg1 ;
  std::vector< std::pair< Date,double > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::pair< Date,double > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NodeVector" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val1);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NodeVector" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NodeVector" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< Date,double > > *)new std::vector< std::pair< Date,double > >(arg1,(std::vector< std::pair< Date,double > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NodeVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NodeVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NodeVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_NodeVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NodeVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::pair< Date,double >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NodeVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NodeVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< Date,double > >::vector()\n"
    "    std::vector< std::pair< Date,double > >::vector(std::vector< std::pair< Date,double > > const &)\n"
    "    std::vector< std::pair< Date,double > >::vector(std::vector< std::pair< Date,double > >::size_type)\n"
    "    std::vector< std::pair< Date,double > >::vector(std::vector< std::pair< Date,double > >::size_type,std::vector< std::pair< Date,double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NodeVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_push_back" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodeVector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::pair< Date,double > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_front" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< Date,double > >::value_type *) &((std::vector< std::pair< Date,double > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< Date,double > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< Date,double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_back" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< Date,double > >::value_type *) &((std::vector< std::pair< Date,double > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< Date,double > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< Date,double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type arg2 ;
  std::vector< std::pair< Date,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_assign" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector_assign" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val2);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodeVector_assign" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_assign" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::pair< Date,double > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type arg2 ;
  std::vector< std::pair< Date,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_resize" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector_resize" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val2);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodeVector_resize" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_resize" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::pair< Date,double > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_NodeVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::iterator arg2 ;
  std::vector< std::pair< Date,double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::pair< Date,double > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_insert" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
    }
  }
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodeVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::pair< Date,double > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< Date,double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::iterator arg2 ;
  std::vector< std::pair< Date,double > >::size_type arg3 ;
  std::vector< std::pair< Date,double > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_insert" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "NodeVector_insert" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodeVector_insert" "', argument " "3"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val3);
  {
    std::pair< Date,double > *ptr = (std::pair< Date,double > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodeVector_insert" "', argument " "4"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodeVector_insert" "', argument " "4"" of type '" "std::vector< std::pair< Date,double > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_Date_Sc_double_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::pair< Date,double > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "NodeVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< Date,double >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_NodeVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< Date,double > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< Date,double >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_NodeVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NodeVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< Date,double > >::insert(std::vector< std::pair< Date,double > >::iterator,std::vector< std::pair< Date,double > >::value_type const &)\n"
    "    std::vector< std::pair< Date,double > >::insert(std::vector< std::pair< Date,double > >::iterator,std::vector< std::pair< Date,double > >::size_type,std::vector< std::pair< Date,double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NodeVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  std::vector< std::pair< Date,double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NodeVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_reserve" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NodeVector_reserve" "', argument " "2"" of type '" "std::vector< std::pair< Date,double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< Date,double > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NodeVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,double > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeVector_capacity" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< Date,double > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NodeVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< Date,double > > *arg1 = (std::vector< std::pair< Date,double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_Date_double_t_std__allocatorT_std__pairT_Date_double_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NodeVector" "', argument " "1"" of type '" "std::vector< std::pair< Date,double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< Date,double > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_Calendar_isWeekend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Weekday arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_isWeekend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_isWeekend" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Calendar_isWeekend" "', argument " "2"" of type '" "Weekday""'");
  } 
  arg2 = static_cast< Weekday >(val2);
  {
    try {
      result = (bool)(arg1)->isWeekend(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_endOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_endOfMonth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_endOfMonth" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_endOfMonth" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_endOfMonth" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (arg1)->endOfMonth((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_isBusinessDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_isBusinessDay", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_isBusinessDay" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_isBusinessDay" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_isBusinessDay" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)(arg1)->isBusinessDay((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_isHoliday(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_isHoliday", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_isHoliday" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_isHoliday" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_isHoliday" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)(arg1)->isHoliday((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_isEndOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_isEndOfMonth", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_isEndOfMonth" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_isEndOfMonth" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_isEndOfMonth" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)(arg1)->isEndOfMonth((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_addHoliday(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_addHoliday", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_addHoliday" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_addHoliday" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_addHoliday" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      (arg1)->addHoliday((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_removeHoliday(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_removeHoliday", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_removeHoliday" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_removeHoliday" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_removeHoliday" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      (arg1)->removeHoliday((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_resetAddedAndRemovedHolidays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_resetAddedAndRemovedHolidays" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  {
    try {
      (arg1)->resetAddedAndRemovedHolidays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_adjust__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Date result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_adjust" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_adjust" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_adjust" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Calendar_adjust" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    try {
      result = (arg1)->adjust((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_adjust__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_adjust" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_adjust" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_adjust" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (arg1)->adjust((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_adjust(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Calendar_adjust", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Calendar_adjust__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Calendar_adjust__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Calendar_adjust'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Calendar::adjust(Date const &,BusinessDayConvention)\n"
    "    Calendar::adjust(Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Integer arg3 ;
  TimeUnit arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Date result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_advance" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Calendar_advance" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_advance" "', argument " "4"" of type '" "TimeUnit""'");
  } 
  arg4 = static_cast< TimeUnit >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Calendar_advance" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Calendar_advance" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Integer arg3 ;
  TimeUnit arg4 ;
  BusinessDayConvention arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Date result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_advance" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Calendar_advance" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_advance" "', argument " "4"" of type '" "TimeUnit""'");
  } 
  arg4 = static_cast< TimeUnit >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Calendar_advance" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Integer arg3 ;
  TimeUnit arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Date result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_advance" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Calendar_advance" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_advance" "', argument " "4"" of type '" "TimeUnit""'");
  } 
  arg4 = static_cast< TimeUnit >(val4);
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Date result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_advance" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_advance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_advance" "', argument " "4"" of type '" "BusinessDayConvention""'");
  } 
  arg4 = static_cast< BusinessDayConvention >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Calendar_advance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Date result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_advance" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_advance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_advance" "', argument " "4"" of type '" "BusinessDayConvention""'");
  } 
  arg4 = static_cast< BusinessDayConvention >(val4);
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Date result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_advance" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_advance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_advance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (arg1)->advance((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_advance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Calendar_advance", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Calendar_advance__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Calendar_advance__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Calendar_advance__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Calendar_advance__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Calendar_advance__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Calendar_advance__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Calendar_advance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Calendar::advance(Date const &,Integer,TimeUnit,BusinessDayConvention,bool)\n"
    "    Calendar::advance(Date const &,Integer,TimeUnit,BusinessDayConvention)\n"
    "    Calendar::advance(Date const &,Integer,TimeUnit)\n"
    "    Calendar::advance(Date const &,Period const &,BusinessDayConvention,bool)\n"
    "    Calendar::advance(Date const &,Period const &,BusinessDayConvention)\n"
    "    Calendar::advance(Date const &,Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Calendar_businessDaysBetween__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  BigInteger result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_businessDaysBetween" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_businessDaysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDaysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_businessDaysBetween" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDaysBetween" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_businessDaysBetween" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Calendar_businessDaysBetween" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (BigInteger)(arg1)->businessDaysBetween((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_businessDaysBetween__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  BigInteger result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_businessDaysBetween" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_businessDaysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDaysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_businessDaysBetween" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDaysBetween" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_businessDaysBetween" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (BigInteger)(arg1)->businessDaysBetween((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_businessDaysBetween__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BigInteger result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_businessDaysBetween" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_businessDaysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDaysBetween" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_businessDaysBetween" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDaysBetween" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (BigInteger)(arg1)->businessDaysBetween((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_businessDaysBetween(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Calendar_businessDaysBetween", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Calendar_businessDaysBetween__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Calendar_businessDaysBetween__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Calendar_businessDaysBetween__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Calendar_businessDaysBetween'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Calendar::businessDaysBetween(Date const &,Date const &,bool,bool)\n"
    "    Calendar::businessDaysBetween(Date const &,Date const &,bool)\n"
    "    Calendar::businessDaysBetween(Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Calendar_holidayList__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  std::vector< Date,std::allocator< Date > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_holidayList" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_holidayList" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_holidayList" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_holidayList" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_holidayList" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Calendar_holidayList" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (arg1)->holidayList((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_holidayList__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< Date,std::allocator< Date > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_holidayList" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_holidayList" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_holidayList" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_holidayList" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_holidayList" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (arg1)->holidayList((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_holidayList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Calendar_holidayList", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Calendar_holidayList__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Calendar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Calendar_holidayList__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Calendar_holidayList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Calendar::holidayList(Date const &,Date const &,bool)\n"
    "    Calendar::holidayList(Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Calendar_businessDayList(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Date,std::allocator< Date > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar_businessDayList", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_businessDayList" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar_businessDayList" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDayList" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Calendar_businessDayList" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar_businessDayList" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (arg1)->businessDayList((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar_name" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  {
    try {
      result = (arg1)->name();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar___str__" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  {
    try {
      result = Calendar___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Calendar___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar___eq__" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar___eq__" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar___eq__" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (bool)Calendar___eq__(arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Calendar___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Calendar___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Calendar___ne__" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Calendar___ne__" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Calendar___ne__" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (bool)Calendar___ne__(arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_Calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Calendar *arg1 = (Calendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Calendar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Calendar" "', argument " "1"" of type '" "Calendar *""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_CalendarVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_iterator" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_Calendar_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___nonzero__" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Calendar_Sg____nonzero__((std::vector< Calendar > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___bool__" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Calendar_Sg____bool__((std::vector< Calendar > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___len__" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = std_vector_Sl_Calendar_Sg____len__((std::vector< Calendar > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  std::vector< Calendar >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Calendar,std::allocator< Calendar > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___getslice__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___getslice__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalendarVector___getslice__" "', argument " "3"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Calendar >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< Calendar,std::allocator< Calendar > > *)std_vector_Sl_Calendar_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  std::vector< Calendar >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___setslice__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___setslice__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalendarVector___setslice__" "', argument " "3"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Calendar >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  std::vector< Calendar >::difference_type arg3 ;
  std::vector< Calendar,std::allocator< Calendar > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___setslice__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___setslice__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalendarVector___setslice__" "', argument " "3"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Calendar >::difference_type >(val3);
  {
    std::vector< Calendar,std::allocator< Calendar > > *ptr = (std::vector< Calendar,std::allocator< Calendar > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalendarVector___setslice__" "', argument " "4"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector___setslice__" "', argument " "4"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< Calendar,std::allocator< Calendar > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalendarVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CalendarVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalendarVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalendarVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Calendar >::__setslice__(std::vector< Calendar >::difference_type,std::vector< Calendar >::difference_type)\n"
    "    std::vector< Calendar >::__setslice__(std::vector< Calendar >::difference_type,std::vector< Calendar >::difference_type,std::vector< Calendar,std::allocator< Calendar > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalendarVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  std::vector< Calendar >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___delslice__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___delslice__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalendarVector___delslice__" "', argument " "3"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Calendar >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___delitem__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___delitem__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Calendar,std::allocator< Calendar > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___getitem__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< Calendar,std::allocator< Calendar > > *)std_vector_Sl_Calendar_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< Calendar,std::allocator< Calendar > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___setitem__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< Calendar,std::allocator< Calendar > > *ptr = (std::vector< Calendar,std::allocator< Calendar > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalendarVector___setitem__" "', argument " "3"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector___setitem__" "', argument " "3"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Calendar,std::allocator< Calendar > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___setitem__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___delitem__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_CalendarVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< Calendar >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___getitem__" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___getitem__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< Calendar >::value_type *) &std_vector_Sl_Calendar_Sg____getitem____SWIG_1((std::vector< Calendar > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Calendar, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Calendar >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_CalendarVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::difference_type arg2 ;
  std::vector< Calendar >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector___setitem__" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector___setitem__" "', argument " "2"" of type '" "std::vector< Calendar >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalendarVector___setitem__" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector___setitem__" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_Calendar_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(Calendar const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalendarVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalendarVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalendarVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalendarVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalendarVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Calendar >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Calendar,std::allocator< Calendar > > const &)\n"
    "    std::vector< Calendar >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Calendar >::__setitem__(std::vector< Calendar >::difference_type,std::vector< Calendar >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalendarVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_pop" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_Calendar_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Calendar >::value_type(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_append" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalendarVector_append" "', argument " "2"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_append" "', argument " "2"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_Calendar_Sg__append(arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalendarVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< Calendar > *)new std::vector< Calendar >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalendarVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< Calendar > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Calendar,std::allocator< Calendar > > *ptr = (std::vector< Calendar,std::allocator< Calendar > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalendarVector" "', argument " "1"" of type '" "std::vector< Calendar > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalendarVector" "', argument " "1"" of type '" "std::vector< Calendar > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< Calendar > *)new std::vector< Calendar >((std::vector< Calendar > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_empty" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (bool)((std::vector< Calendar > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_size" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = ((std::vector< Calendar > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_swap" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalendarVector_swap" "', argument " "2"" of type '" "std::vector< Calendar > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_swap" "', argument " "2"" of type '" "std::vector< Calendar > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Calendar > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_begin" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_end" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_rbegin" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_rend" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_clear" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< Calendar > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_get_allocator" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = ((std::vector< Calendar > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Calendar >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_Calendar_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalendarVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< Calendar > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalendarVector" "', argument " "1"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Calendar >::size_type >(val1);
  {
    try {
      result = (std::vector< Calendar > *)new std::vector< Calendar >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_pop_back" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_resize" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector_resize" "', argument " "2"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< Calendar >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_erase" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_erase" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_erase" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Calendar_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::iterator arg2 ;
  std::vector< Calendar >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< Calendar >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_erase" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_erase" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_erase" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_erase" "', argument " "3"" of type '" "std::vector< Calendar >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_erase" "', argument " "3"" of type '" "std::vector< Calendar >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Calendar_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalendarVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_CalendarVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_CalendarVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalendarVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Calendar >::erase(std::vector< Calendar >::iterator)\n"
    "    std::vector< Calendar >::erase(std::vector< Calendar >::iterator,std::vector< Calendar >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CalendarVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar >::size_type arg1 ;
  std::vector< Calendar >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< Calendar > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalendarVector" "', argument " "1"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Calendar >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CalendarVector" "', argument " "2"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalendarVector" "', argument " "2"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp2);
  {
    try {
      result = (std::vector< Calendar > *)new std::vector< Calendar >(arg1,(std::vector< Calendar >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalendarVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CalendarVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CalendarVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CalendarVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalendarVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CalendarVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CalendarVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Calendar >::vector()\n"
    "    std::vector< Calendar >::vector(std::vector< Calendar > const &)\n"
    "    std::vector< Calendar >::vector(std::vector< Calendar >::size_type)\n"
    "    std::vector< Calendar >::vector(std::vector< Calendar >::size_type,std::vector< Calendar >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalendarVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_push_back" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalendarVector_push_back" "', argument " "2"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_push_back" "', argument " "2"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< Calendar >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_front" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (std::vector< Calendar >::value_type *) &((std::vector< Calendar > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Calendar, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Calendar >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_back" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = (std::vector< Calendar >::value_type *) &((std::vector< Calendar > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Calendar, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Calendar >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type arg2 ;
  std::vector< Calendar >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_assign" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector_assign" "', argument " "2"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalendarVector_assign" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_assign" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< Calendar >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type arg2 ;
  std::vector< Calendar >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_resize" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector_resize" "', argument " "2"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalendarVector_resize" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_resize" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< Calendar >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalendarVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalendarVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalendarVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalendarVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Calendar >::resize(std::vector< Calendar >::size_type)\n"
    "    std::vector< Calendar >::resize(std::vector< Calendar >::size_type,std::vector< Calendar >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalendarVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::iterator arg2 ;
  std::vector< Calendar >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< Calendar >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_insert" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_insert" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_insert" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalendarVector_insert" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_insert" "', argument " "3"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_Calendar_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(Calendar const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Calendar >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::iterator arg2 ;
  std::vector< Calendar >::size_type arg3 ;
  std::vector< Calendar >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_insert" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_insert" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalendarVector_insert" "', argument " "2"" of type '" "std::vector< Calendar >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalendarVector_insert" "', argument " "3"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Calendar >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalendarVector_insert" "', argument " "4"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalendarVector_insert" "', argument " "4"" of type '" "std::vector< Calendar >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Calendar >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_Calendar_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalendarVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalendarVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Calendar >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalendarVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalendarVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Calendar >::insert(std::vector< Calendar >::iterator,std::vector< Calendar >::value_type const &)\n"
    "    std::vector< Calendar >::insert(std::vector< Calendar >::iterator,std::vector< Calendar >::size_type,std::vector< Calendar >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalendarVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  std::vector< Calendar >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalendarVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_reserve" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalendarVector_reserve" "', argument " "2"" of type '" "std::vector< Calendar >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Calendar >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalendarVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Calendar >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalendarVector_capacity" "', argument " "1"" of type '" "std::vector< Calendar > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      result = ((std::vector< Calendar > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalendarVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Calendar > *arg1 = (std::vector< Calendar > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_Calendar_std__allocatorT_Calendar_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalendarVector" "', argument " "1"" of type '" "std::vector< Calendar > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Calendar > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Argentina__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Argentina::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Argentina *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Argentina" "', argument " "1"" of type '" "QuantLib::Argentina::Market""'");
  } 
  arg1 = static_cast< QuantLib::Argentina::Market >(val1);
  {
    try {
      result = (QuantLib::Argentina *)new QuantLib::Argentina(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Argentina, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Argentina__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Argentina *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Argentina *)new QuantLib::Argentina();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Argentina, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Argentina(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Argentina", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Argentina__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Argentina__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Argentina'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Argentina::Argentina(QuantLib::Argentina::Market)\n"
    "    QuantLib::Argentina::Argentina()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Argentina(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Argentina *arg1 = (QuantLib::Argentina *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Argentina, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Argentina" "', argument " "1"" of type '" "QuantLib::Argentina *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Argentina * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Australia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Australia::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Australia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Australia" "', argument " "1"" of type '" "QuantLib::Australia::Market""'");
  } 
  arg1 = static_cast< QuantLib::Australia::Market >(val1);
  {
    try {
      result = (QuantLib::Australia *)new QuantLib::Australia(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Australia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Australia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Australia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Australia *)new QuantLib::Australia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Australia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Australia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Australia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Australia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Australia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Australia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Australia::Australia(QuantLib::Australia::Market)\n"
    "    QuantLib::Australia::Australia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Australia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Australia *arg1 = (QuantLib::Australia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Australia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Australia" "', argument " "1"" of type '" "QuantLib::Australia *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Australia * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Austria__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Austria::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Austria *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Austria" "', argument " "1"" of type '" "QuantLib::Austria::Market""'");
  } 
  arg1 = static_cast< QuantLib::Austria::Market >(val1);
  {
    try {
      result = (QuantLib::Austria *)new QuantLib::Austria(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Austria, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Austria__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Austria *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Austria *)new QuantLib::Austria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Austria, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Austria(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Austria", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Austria__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Austria__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Austria'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Austria::Austria(QuantLib::Austria::Market)\n"
    "    QuantLib::Austria::Austria()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Austria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Austria *arg1 = (QuantLib::Austria *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Austria, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Austria" "', argument " "1"" of type '" "QuantLib::Austria *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Austria * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Botswana(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Botswana *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Botswana", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Botswana *)new QuantLib::Botswana();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Botswana, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Botswana(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Botswana *arg1 = (QuantLib::Botswana *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Botswana, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Botswana" "', argument " "1"" of type '" "QuantLib::Botswana *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Botswana * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Brazil__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Brazil::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Brazil *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Brazil" "', argument " "1"" of type '" "QuantLib::Brazil::Market""'");
  } 
  arg1 = static_cast< QuantLib::Brazil::Market >(val1);
  {
    try {
      result = (QuantLib::Brazil *)new QuantLib::Brazil(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Brazil, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Brazil__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Brazil *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Brazil *)new QuantLib::Brazil();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Brazil, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Brazil(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Brazil", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Brazil__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Brazil__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Brazil'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Brazil::Brazil(QuantLib::Brazil::Market)\n"
    "    QuantLib::Brazil::Brazil()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Brazil(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Brazil *arg1 = (QuantLib::Brazil *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Brazil, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brazil" "', argument " "1"" of type '" "QuantLib::Brazil *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Brazil * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Canada__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Canada::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Canada *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Canada" "', argument " "1"" of type '" "QuantLib::Canada::Market""'");
  } 
  arg1 = static_cast< QuantLib::Canada::Market >(val1);
  {
    try {
      result = (QuantLib::Canada *)new QuantLib::Canada(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Canada, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Canada__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Canada *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Canada *)new QuantLib::Canada();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Canada, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Canada(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Canada", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Canada__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Canada__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Canada'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Canada::Canada(QuantLib::Canada::Market)\n"
    "    QuantLib::Canada::Canada()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Canada(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Canada *arg1 = (QuantLib::Canada *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Canada, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Canada" "', argument " "1"" of type '" "QuantLib::Canada *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Canada * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Chile__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Chile::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Chile *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Chile" "', argument " "1"" of type '" "QuantLib::Chile::Market""'");
  } 
  arg1 = static_cast< QuantLib::Chile::Market >(val1);
  {
    try {
      result = (QuantLib::Chile *)new QuantLib::Chile(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Chile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Chile__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Chile *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Chile *)new QuantLib::Chile();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Chile, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Chile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Chile", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Chile__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Chile__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Chile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Chile::Chile(QuantLib::Chile::Market)\n"
    "    QuantLib::Chile::Chile()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Chile(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Chile *arg1 = (QuantLib::Chile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Chile, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Chile" "', argument " "1"" of type '" "QuantLib::Chile *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Chile * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_China__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::China::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::China *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_China" "', argument " "1"" of type '" "QuantLib::China::Market""'");
  } 
  arg1 = static_cast< QuantLib::China::Market >(val1);
  {
    try {
      result = (QuantLib::China *)new QuantLib::China(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__China, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_China__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::China *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::China *)new QuantLib::China();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__China, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_China(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_China", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_China__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_China__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_China'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::China::China(QuantLib::China::Market)\n"
    "    QuantLib::China::China()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_China(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::China *arg1 = (QuantLib::China *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__China, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_China" "', argument " "1"" of type '" "QuantLib::China *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::China * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CzechRepublic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::CzechRepublic::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::CzechRepublic *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CzechRepublic" "', argument " "1"" of type '" "QuantLib::CzechRepublic::Market""'");
  } 
  arg1 = static_cast< QuantLib::CzechRepublic::Market >(val1);
  {
    try {
      result = (QuantLib::CzechRepublic *)new QuantLib::CzechRepublic(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CzechRepublic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CzechRepublic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::CzechRepublic *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CzechRepublic *)new QuantLib::CzechRepublic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CzechRepublic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CzechRepublic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CzechRepublic", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CzechRepublic__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CzechRepublic__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CzechRepublic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::CzechRepublic::CzechRepublic(QuantLib::CzechRepublic::Market)\n"
    "    QuantLib::CzechRepublic::CzechRepublic()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CzechRepublic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CzechRepublic *arg1 = (QuantLib::CzechRepublic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CzechRepublic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CzechRepublic" "', argument " "1"" of type '" "QuantLib::CzechRepublic *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CzechRepublic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Denmark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Denmark *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Denmark", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Denmark *)new QuantLib::Denmark();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Denmark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Denmark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Denmark *arg1 = (QuantLib::Denmark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Denmark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Denmark" "', argument " "1"" of type '" "QuantLib::Denmark *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Denmark * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Finland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Finland *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Finland", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Finland *)new QuantLib::Finland();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Finland, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Finland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Finland *arg1 = (QuantLib::Finland *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Finland, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Finland" "', argument " "1"" of type '" "QuantLib::Finland *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Finland * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_France__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::France::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::France *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_France" "', argument " "1"" of type '" "QuantLib::France::Market""'");
  } 
  arg1 = static_cast< QuantLib::France::Market >(val1);
  {
    try {
      result = (QuantLib::France *)new QuantLib::France(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__France, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_France__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::France *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::France *)new QuantLib::France();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__France, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_France(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_France", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_France__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_France__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_France'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::France::France(QuantLib::France::Market)\n"
    "    QuantLib::France::France()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_France(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::France *arg1 = (QuantLib::France *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__France, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_France" "', argument " "1"" of type '" "QuantLib::France *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::France * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Germany__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Germany::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Germany *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Germany" "', argument " "1"" of type '" "QuantLib::Germany::Market""'");
  } 
  arg1 = static_cast< QuantLib::Germany::Market >(val1);
  {
    try {
      result = (QuantLib::Germany *)new QuantLib::Germany(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Germany, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Germany__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Germany *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Germany *)new QuantLib::Germany();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Germany, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Germany(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Germany", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Germany__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Germany__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Germany'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Germany::Germany(QuantLib::Germany::Market)\n"
    "    QuantLib::Germany::Germany()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Germany(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Germany *arg1 = (QuantLib::Germany *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Germany, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Germany" "', argument " "1"" of type '" "QuantLib::Germany *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Germany * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_HongKong__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::HongKong::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::HongKong *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HongKong" "', argument " "1"" of type '" "QuantLib::HongKong::Market""'");
  } 
  arg1 = static_cast< QuantLib::HongKong::Market >(val1);
  {
    try {
      result = (QuantLib::HongKong *)new QuantLib::HongKong(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__HongKong, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HongKong__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::HongKong *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::HongKong *)new QuantLib::HongKong();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__HongKong, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HongKong(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HongKong", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_HongKong__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HongKong__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HongKong'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::HongKong::HongKong(QuantLib::HongKong::Market)\n"
    "    QuantLib::HongKong::HongKong()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HongKong(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HongKong *arg1 = (QuantLib::HongKong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__HongKong, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HongKong" "', argument " "1"" of type '" "QuantLib::HongKong *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::HongKong * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Hungary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Hungary *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Hungary", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Hungary *)new QuantLib::Hungary();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Hungary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Hungary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Hungary *arg1 = (QuantLib::Hungary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Hungary, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hungary" "', argument " "1"" of type '" "QuantLib::Hungary *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Hungary * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Iceland__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Iceland::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Iceland *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Iceland" "', argument " "1"" of type '" "QuantLib::Iceland::Market""'");
  } 
  arg1 = static_cast< QuantLib::Iceland::Market >(val1);
  {
    try {
      result = (QuantLib::Iceland *)new QuantLib::Iceland(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Iceland, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Iceland__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Iceland *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Iceland *)new QuantLib::Iceland();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Iceland, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Iceland(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Iceland", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Iceland__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Iceland__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Iceland'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Iceland::Iceland(QuantLib::Iceland::Market)\n"
    "    QuantLib::Iceland::Iceland()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Iceland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Iceland *arg1 = (QuantLib::Iceland *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Iceland, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Iceland" "', argument " "1"" of type '" "QuantLib::Iceland *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Iceland * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_India__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::India::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::India *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_India" "', argument " "1"" of type '" "QuantLib::India::Market""'");
  } 
  arg1 = static_cast< QuantLib::India::Market >(val1);
  {
    try {
      result = (QuantLib::India *)new QuantLib::India(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__India, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_India__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::India *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::India *)new QuantLib::India();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__India, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_India(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_India", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_India__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_India__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_India'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::India::India(QuantLib::India::Market)\n"
    "    QuantLib::India::India()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_India(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::India *arg1 = (QuantLib::India *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__India, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_India" "', argument " "1"" of type '" "QuantLib::India *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::India * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Indonesia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Indonesia::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Indonesia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Indonesia" "', argument " "1"" of type '" "QuantLib::Indonesia::Market""'");
  } 
  arg1 = static_cast< QuantLib::Indonesia::Market >(val1);
  {
    try {
      result = (QuantLib::Indonesia *)new QuantLib::Indonesia(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Indonesia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Indonesia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Indonesia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Indonesia *)new QuantLib::Indonesia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Indonesia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Indonesia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Indonesia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Indonesia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Indonesia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Indonesia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Indonesia::Indonesia(QuantLib::Indonesia::Market)\n"
    "    QuantLib::Indonesia::Indonesia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Indonesia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Indonesia *arg1 = (QuantLib::Indonesia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Indonesia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Indonesia" "', argument " "1"" of type '" "QuantLib::Indonesia *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Indonesia * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Israel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Israel::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Israel *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Israel" "', argument " "1"" of type '" "QuantLib::Israel::Market""'");
  } 
  arg1 = static_cast< QuantLib::Israel::Market >(val1);
  {
    try {
      result = (QuantLib::Israel *)new QuantLib::Israel(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Israel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Israel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Israel *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Israel *)new QuantLib::Israel();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Israel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Israel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Israel", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Israel__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Israel__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Israel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Israel::Israel(QuantLib::Israel::Market)\n"
    "    QuantLib::Israel::Israel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Israel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Israel *arg1 = (QuantLib::Israel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Israel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Israel" "', argument " "1"" of type '" "QuantLib::Israel *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Israel * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Italy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Italy::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Italy *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Italy" "', argument " "1"" of type '" "QuantLib::Italy::Market""'");
  } 
  arg1 = static_cast< QuantLib::Italy::Market >(val1);
  {
    try {
      result = (QuantLib::Italy *)new QuantLib::Italy(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Italy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Italy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Italy *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Italy *)new QuantLib::Italy();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Italy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Italy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Italy", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Italy__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Italy__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Italy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Italy::Italy(QuantLib::Italy::Market)\n"
    "    QuantLib::Italy::Italy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Italy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Italy *arg1 = (QuantLib::Italy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Italy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Italy" "', argument " "1"" of type '" "QuantLib::Italy *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Italy * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Japan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Japan *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Japan", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Japan *)new QuantLib::Japan();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Japan, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Japan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Japan *arg1 = (QuantLib::Japan *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Japan, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Japan" "', argument " "1"" of type '" "QuantLib::Japan *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Japan * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Mexico__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Mexico::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Mexico *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Mexico" "', argument " "1"" of type '" "QuantLib::Mexico::Market""'");
  } 
  arg1 = static_cast< QuantLib::Mexico::Market >(val1);
  {
    try {
      result = (QuantLib::Mexico *)new QuantLib::Mexico(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Mexico, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mexico__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Mexico *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Mexico *)new QuantLib::Mexico();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Mexico, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mexico(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mexico", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Mexico__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Mexico__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Mexico'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Mexico::Mexico(QuantLib::Mexico::Market)\n"
    "    QuantLib::Mexico::Mexico()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Mexico(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Mexico *arg1 = (QuantLib::Mexico *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Mexico, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mexico" "', argument " "1"" of type '" "QuantLib::Mexico *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Mexico * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NewZealand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NewZealand *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NewZealand", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NewZealand *)new QuantLib::NewZealand();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NewZealand, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NewZealand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NewZealand *arg1 = (QuantLib::NewZealand *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NewZealand, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewZealand" "', argument " "1"" of type '" "QuantLib::NewZealand *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NewZealand * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Norway(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Norway *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Norway", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Norway *)new QuantLib::Norway();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Norway, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Norway(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Norway *arg1 = (QuantLib::Norway *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Norway, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Norway" "', argument " "1"" of type '" "QuantLib::Norway *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Norway * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Poland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Poland *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Poland", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Poland *)new QuantLib::Poland();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Poland, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Poland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Poland *arg1 = (QuantLib::Poland *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Poland, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Poland" "', argument " "1"" of type '" "QuantLib::Poland *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Poland * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Romania__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Romania::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Romania *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Romania" "', argument " "1"" of type '" "QuantLib::Romania::Market""'");
  } 
  arg1 = static_cast< QuantLib::Romania::Market >(val1);
  {
    try {
      result = (QuantLib::Romania *)new QuantLib::Romania(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Romania, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Romania__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Romania *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Romania *)new QuantLib::Romania();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Romania, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Romania(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Romania", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Romania__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Romania__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Romania'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Romania::Romania(QuantLib::Romania::Market)\n"
    "    QuantLib::Romania::Romania()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Romania(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Romania *arg1 = (QuantLib::Romania *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Romania, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Romania" "', argument " "1"" of type '" "QuantLib::Romania *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Romania * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Russia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Russia::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Russia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Russia" "', argument " "1"" of type '" "QuantLib::Russia::Market""'");
  } 
  arg1 = static_cast< QuantLib::Russia::Market >(val1);
  {
    try {
      result = (QuantLib::Russia *)new QuantLib::Russia(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Russia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Russia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Russia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Russia *)new QuantLib::Russia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Russia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Russia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Russia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Russia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Russia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Russia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Russia::Russia(QuantLib::Russia::Market)\n"
    "    QuantLib::Russia::Russia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Russia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Russia *arg1 = (QuantLib::Russia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Russia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Russia" "', argument " "1"" of type '" "QuantLib::Russia *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Russia * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SaudiArabia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::SaudiArabia::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::SaudiArabia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SaudiArabia" "', argument " "1"" of type '" "QuantLib::SaudiArabia::Market""'");
  } 
  arg1 = static_cast< QuantLib::SaudiArabia::Market >(val1);
  {
    try {
      result = (QuantLib::SaudiArabia *)new QuantLib::SaudiArabia(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SaudiArabia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SaudiArabia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::SaudiArabia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SaudiArabia *)new QuantLib::SaudiArabia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SaudiArabia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SaudiArabia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SaudiArabia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SaudiArabia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SaudiArabia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SaudiArabia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::SaudiArabia::SaudiArabia(QuantLib::SaudiArabia::Market)\n"
    "    QuantLib::SaudiArabia::SaudiArabia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SaudiArabia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SaudiArabia *arg1 = (QuantLib::SaudiArabia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SaudiArabia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SaudiArabia" "', argument " "1"" of type '" "QuantLib::SaudiArabia *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SaudiArabia * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Singapore__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Singapore::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Singapore *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Singapore" "', argument " "1"" of type '" "QuantLib::Singapore::Market""'");
  } 
  arg1 = static_cast< QuantLib::Singapore::Market >(val1);
  {
    try {
      result = (QuantLib::Singapore *)new QuantLib::Singapore(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Singapore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Singapore__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Singapore *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Singapore *)new QuantLib::Singapore();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Singapore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Singapore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Singapore", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Singapore__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Singapore__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Singapore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Singapore::Singapore(QuantLib::Singapore::Market)\n"
    "    QuantLib::Singapore::Singapore()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Singapore(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Singapore *arg1 = (QuantLib::Singapore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Singapore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Singapore" "', argument " "1"" of type '" "QuantLib::Singapore *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Singapore * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Slovakia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Slovakia::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Slovakia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Slovakia" "', argument " "1"" of type '" "QuantLib::Slovakia::Market""'");
  } 
  arg1 = static_cast< QuantLib::Slovakia::Market >(val1);
  {
    try {
      result = (QuantLib::Slovakia *)new QuantLib::Slovakia(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Slovakia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slovakia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Slovakia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Slovakia *)new QuantLib::Slovakia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Slovakia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Slovakia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Slovakia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Slovakia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Slovakia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Slovakia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Slovakia::Slovakia(QuantLib::Slovakia::Market)\n"
    "    QuantLib::Slovakia::Slovakia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Slovakia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Slovakia *arg1 = (QuantLib::Slovakia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Slovakia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Slovakia" "', argument " "1"" of type '" "QuantLib::Slovakia *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Slovakia * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SouthAfrica(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SouthAfrica *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SouthAfrica", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SouthAfrica *)new QuantLib::SouthAfrica();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SouthAfrica, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SouthAfrica(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SouthAfrica *arg1 = (QuantLib::SouthAfrica *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SouthAfrica, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SouthAfrica" "', argument " "1"" of type '" "QuantLib::SouthAfrica *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SouthAfrica * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SouthKorea__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::SouthKorea::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::SouthKorea *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SouthKorea" "', argument " "1"" of type '" "QuantLib::SouthKorea::Market""'");
  } 
  arg1 = static_cast< QuantLib::SouthKorea::Market >(val1);
  {
    try {
      result = (QuantLib::SouthKorea *)new QuantLib::SouthKorea(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SouthKorea, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SouthKorea__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::SouthKorea *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SouthKorea *)new QuantLib::SouthKorea();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SouthKorea, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SouthKorea(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SouthKorea", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SouthKorea__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SouthKorea__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SouthKorea'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::SouthKorea::SouthKorea(QuantLib::SouthKorea::Market)\n"
    "    QuantLib::SouthKorea::SouthKorea()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SouthKorea(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SouthKorea *arg1 = (QuantLib::SouthKorea *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SouthKorea, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SouthKorea" "', argument " "1"" of type '" "QuantLib::SouthKorea *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SouthKorea * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Sweden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Sweden *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Sweden", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Sweden *)new QuantLib::Sweden();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Sweden, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sweden(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Sweden *arg1 = (QuantLib::Sweden *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Sweden, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sweden" "', argument " "1"" of type '" "QuantLib::Sweden *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Sweden * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Switzerland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Switzerland *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Switzerland", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Switzerland *)new QuantLib::Switzerland();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Switzerland, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Switzerland(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Switzerland *arg1 = (QuantLib::Switzerland *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Switzerland, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Switzerland" "', argument " "1"" of type '" "QuantLib::Switzerland *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Switzerland * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Taiwan__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Taiwan::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Taiwan *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Taiwan" "', argument " "1"" of type '" "QuantLib::Taiwan::Market""'");
  } 
  arg1 = static_cast< QuantLib::Taiwan::Market >(val1);
  {
    try {
      result = (QuantLib::Taiwan *)new QuantLib::Taiwan(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Taiwan, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Taiwan__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Taiwan *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Taiwan *)new QuantLib::Taiwan();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Taiwan, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Taiwan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Taiwan", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Taiwan__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Taiwan__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Taiwan'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Taiwan::Taiwan(QuantLib::Taiwan::Market)\n"
    "    QuantLib::Taiwan::Taiwan()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Taiwan(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Taiwan *arg1 = (QuantLib::Taiwan *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Taiwan, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Taiwan" "', argument " "1"" of type '" "QuantLib::Taiwan *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Taiwan * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TARGET(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TARGET *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TARGET", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::TARGET *)new QuantLib::TARGET();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__TARGET, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TARGET(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TARGET *arg1 = (QuantLib::TARGET *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__TARGET, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TARGET" "', argument " "1"" of type '" "QuantLib::TARGET *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::TARGET * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Thailand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Thailand *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Thailand", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Thailand *)new QuantLib::Thailand();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Thailand, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Thailand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Thailand *arg1 = (QuantLib::Thailand *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Thailand, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Thailand" "', argument " "1"" of type '" "QuantLib::Thailand *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Thailand * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Turkey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Turkey *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Turkey", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Turkey *)new QuantLib::Turkey();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Turkey, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Turkey(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Turkey *arg1 = (QuantLib::Turkey *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Turkey, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Turkey" "', argument " "1"" of type '" "QuantLib::Turkey *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Turkey * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Ukraine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Ukraine::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Ukraine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Ukraine" "', argument " "1"" of type '" "QuantLib::Ukraine::Market""'");
  } 
  arg1 = static_cast< QuantLib::Ukraine::Market >(val1);
  {
    try {
      result = (QuantLib::Ukraine *)new QuantLib::Ukraine(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Ukraine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Ukraine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Ukraine *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Ukraine *)new QuantLib::Ukraine();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Ukraine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Ukraine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Ukraine", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Ukraine__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Ukraine__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Ukraine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Ukraine::Ukraine(QuantLib::Ukraine::Market)\n"
    "    QuantLib::Ukraine::Ukraine()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Ukraine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Ukraine *arg1 = (QuantLib::Ukraine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Ukraine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ukraine" "', argument " "1"" of type '" "QuantLib::Ukraine *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Ukraine * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UnitedKingdom__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::UnitedKingdom::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::UnitedKingdom *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnitedKingdom" "', argument " "1"" of type '" "QuantLib::UnitedKingdom::Market""'");
  } 
  arg1 = static_cast< QuantLib::UnitedKingdom::Market >(val1);
  {
    try {
      result = (QuantLib::UnitedKingdom *)new QuantLib::UnitedKingdom(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__UnitedKingdom, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitedKingdom__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::UnitedKingdom *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::UnitedKingdom *)new QuantLib::UnitedKingdom();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__UnitedKingdom, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitedKingdom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UnitedKingdom", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UnitedKingdom__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UnitedKingdom__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UnitedKingdom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::UnitedKingdom::UnitedKingdom(QuantLib::UnitedKingdom::Market)\n"
    "    QuantLib::UnitedKingdom::UnitedKingdom()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnitedKingdom(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UnitedKingdom *arg1 = (QuantLib::UnitedKingdom *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__UnitedKingdom, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitedKingdom" "', argument " "1"" of type '" "QuantLib::UnitedKingdom *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::UnitedKingdom * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UnitedStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UnitedStates::Market arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  QuantLib::UnitedStates *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnitedStates" "', argument " "1"" of type '" "QuantLib::UnitedStates::Market""'");
  } 
  arg1 = static_cast< QuantLib::UnitedStates::Market >(val1);
  {
    try {
      result = (QuantLib::UnitedStates *)new QuantLib::UnitedStates(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__UnitedStates, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UnitedStates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UnitedStates *arg1 = (QuantLib::UnitedStates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__UnitedStates, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitedStates" "', argument " "1"" of type '" "QuantLib::UnitedStates *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::UnitedStates * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NullCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NullCalendar *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NullCalendar", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NullCalendar *)new QuantLib::NullCalendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NullCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NullCalendar *arg1 = (QuantLib::NullCalendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NullCalendar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullCalendar" "', argument " "1"" of type '" "QuantLib::NullCalendar *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NullCalendar * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_WeekendsOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::WeekendsOnly *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_WeekendsOnly", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::WeekendsOnly *)new QuantLib::WeekendsOnly();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__WeekendsOnly, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_WeekendsOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::WeekendsOnly *arg1 = (QuantLib::WeekendsOnly *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__WeekendsOnly, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WeekendsOnly" "', argument " "1"" of type '" "QuantLib::WeekendsOnly *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::WeekendsOnly * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  JointCalendarRule arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JointCalendar" "', argument " "3"" of type '" "JointCalendarRule""'");
  } 
  arg3 = static_cast< JointCalendarRule >(val3);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  JointCalendarRule arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JointCalendar" "', argument " "4"" of type '" "JointCalendarRule""'");
  } 
  arg4 = static_cast< JointCalendarRule >(val4);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  JointCalendarRule arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_JointCalendar" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_JointCalendar" "', argument " "5"" of type '" "JointCalendarRule""'");
  } 
  arg5 = static_cast< JointCalendarRule >(val5);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3,(Calendar const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_JointCalendar" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((Calendar const &)*arg1,(Calendar const &)*arg2,(Calendar const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar,std::allocator< Calendar > > *arg1 = 0 ;
  JointCalendarRule arg2 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< Calendar,std::allocator< Calendar > > *ptr = (std::vector< Calendar,std::allocator< Calendar > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JointCalendar" "', argument " "2"" of type '" "JointCalendarRule""'");
  } 
  arg2 = static_cast< JointCalendarRule >(val2);
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((std::vector< Calendar,std::allocator< Calendar > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Calendar,std::allocator< Calendar > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  QuantLib::JointCalendar *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Calendar,std::allocator< Calendar > > *ptr = (std::vector< Calendar,std::allocator< Calendar > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointCalendar" "', argument " "1"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointCalendar" "', argument " "1"" of type '" "std::vector< Calendar,std::allocator< Calendar > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (QuantLib::JointCalendar *)new QuantLib::JointCalendar((std::vector< Calendar,std::allocator< Calendar > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JointCalendar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_JointCalendar", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JointCalendar__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_JointCalendar__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Calendar,std::allocator< Calendar > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_JointCalendar__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_JointCalendar__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_JointCalendar__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_JointCalendar__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_JointCalendar__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_JointCalendar__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JointCalendar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::JointCalendar::JointCalendar(Calendar const &,Calendar const &,JointCalendarRule)\n"
    "    QuantLib::JointCalendar::JointCalendar(Calendar const &,Calendar const &)\n"
    "    QuantLib::JointCalendar::JointCalendar(Calendar const &,Calendar const &,Calendar const &,JointCalendarRule)\n"
    "    QuantLib::JointCalendar::JointCalendar(Calendar const &,Calendar const &,Calendar const &)\n"
    "    QuantLib::JointCalendar::JointCalendar(Calendar const &,Calendar const &,Calendar const &,Calendar const &,JointCalendarRule)\n"
    "    QuantLib::JointCalendar::JointCalendar(Calendar const &,Calendar const &,Calendar const &,Calendar const &)\n"
    "    QuantLib::JointCalendar::JointCalendar(std::vector< Calendar,std::allocator< Calendar > > const &,JointCalendarRule)\n"
    "    QuantLib::JointCalendar::JointCalendar(std::vector< Calendar,std::allocator< Calendar > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_JointCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::JointCalendar *arg1 = (QuantLib::JointCalendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__JointCalendar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JointCalendar" "', argument " "1"" of type '" "QuantLib::JointCalendar *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::JointCalendar * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BespokeCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  QuantLib::BespokeCalendar *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BespokeCalendar" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BespokeCalendar" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (QuantLib::BespokeCalendar *)new QuantLib::BespokeCalendar((std::string const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BespokeCalendar, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BespokeCalendar_addWeekend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BespokeCalendar *arg1 = (QuantLib::BespokeCalendar *) 0 ;
  Weekday arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BespokeCalendar_addWeekend", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BespokeCalendar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BespokeCalendar_addWeekend" "', argument " "1"" of type '" "QuantLib::BespokeCalendar *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BespokeCalendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BespokeCalendar_addWeekend" "', argument " "2"" of type '" "Weekday""'");
  } 
  arg2 = static_cast< Weekday >(val2);
  {
    try {
      (arg1)->addWeekend(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BespokeCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BespokeCalendar *arg1 = (QuantLib::BespokeCalendar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BespokeCalendar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BespokeCalendar" "', argument " "1"" of type '" "QuantLib::BespokeCalendar *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BespokeCalendar * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_nullInt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "nullInt", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)nullInt();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nullDouble(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "nullDouble", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (double)nullDouble();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter_dayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  BigInteger result;
  
  if (!SWIG_Python_UnpackTuple(args, "DayCounter_dayCount", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter_dayCount" "', argument " "1"" of type '" "DayCounter const *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DayCounter_dayCount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_dayCount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DayCounter_dayCount" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_dayCount" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (BigInteger)((DayCounter const *)arg1)->dayCount((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter_yearFraction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Time result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter_yearFraction" "', argument " "1"" of type '" "DayCounter const *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DayCounter_yearFraction" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DayCounter_yearFraction" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DayCounter_yearFraction" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DayCounter_yearFraction" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Time)((DayCounter const *)arg1)->yearFraction((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter_yearFraction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Time result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter_yearFraction" "', argument " "1"" of type '" "DayCounter const *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DayCounter_yearFraction" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DayCounter_yearFraction" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DayCounter_yearFraction" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Time)((DayCounter const *)arg1)->yearFraction((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter_yearFraction__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Time result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter_yearFraction" "', argument " "1"" of type '" "DayCounter const *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DayCounter_yearFraction" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DayCounter_yearFraction" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter_yearFraction" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Time)((DayCounter const *)arg1)->yearFraction((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter_yearFraction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DayCounter_yearFraction", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_DayCounter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DayCounter_yearFraction__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_DayCounter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DayCounter_yearFraction__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_DayCounter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_DayCounter_yearFraction__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DayCounter_yearFraction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DayCounter::yearFraction(Date const &,Date const &,Date const &,Date const &) const\n"
    "    DayCounter::yearFraction(Date const &,Date const &,Date const &) const\n"
    "    DayCounter::yearFraction(Date const &,Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DayCounter_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter_name" "', argument " "1"" of type '" "DayCounter const *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  {
    try {
      result = ((DayCounter const *)arg1)->name();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter___str__" "', argument " "1"" of type '" "DayCounter *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  {
    try {
      result = DayCounter___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DayCounter___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  DayCounter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DayCounter___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter___eq__" "', argument " "1"" of type '" "DayCounter *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DayCounter___eq__" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter___eq__" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    try {
      result = (bool)DayCounter___eq__(arg1,(DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_DayCounter___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  DayCounter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "DayCounter___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DayCounter___ne__" "', argument " "1"" of type '" "DayCounter *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DayCounter___ne__" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DayCounter___ne__" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    try {
      result = (bool)DayCounter___ne__(arg1,(DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_DayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = (DayCounter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DayCounter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DayCounter" "', argument " "1"" of type '" "DayCounter *""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Actual360__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  QuantLib::Actual360 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Actual360" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (QuantLib::Actual360 *)new QuantLib::Actual360(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual360, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual360__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Actual360 *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Actual360 *)new QuantLib::Actual360();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual360, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual360(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Actual360", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Actual360__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Actual360__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Actual360'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Actual360::Actual360(bool const)\n"
    "    QuantLib::Actual360::Actual360()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Actual360(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Actual360 *arg1 = (QuantLib::Actual360 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Actual360, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Actual360" "', argument " "1"" of type '" "QuantLib::Actual360 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Actual360 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Actual366__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  QuantLib::Actual366 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Actual366" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (QuantLib::Actual366 *)new QuantLib::Actual366(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual366, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual366__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Actual366 *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Actual366 *)new QuantLib::Actual366();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual366, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual366(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Actual366", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Actual366__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Actual366__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Actual366'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Actual366::Actual366(bool const)\n"
    "    QuantLib::Actual366::Actual366()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Actual366(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Actual366 *arg1 = (QuantLib::Actual366 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Actual366, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Actual366" "', argument " "1"" of type '" "QuantLib::Actual366 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Actual366 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Actual36525__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  QuantLib::Actual36525 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Actual36525" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (QuantLib::Actual36525 *)new QuantLib::Actual36525(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual36525, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual36525__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Actual36525 *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Actual36525 *)new QuantLib::Actual36525();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual36525, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual36525(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Actual36525", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Actual36525__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Actual36525__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Actual36525'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Actual36525::Actual36525(bool const)\n"
    "    QuantLib::Actual36525::Actual36525()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Actual36525(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Actual36525 *arg1 = (QuantLib::Actual36525 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Actual36525, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Actual36525" "', argument " "1"" of type '" "QuantLib::Actual36525 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Actual36525 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Actual364(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Actual364 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Actual364", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Actual364 *)new QuantLib::Actual364();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual364, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Actual364(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Actual364 *arg1 = (QuantLib::Actual364 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Actual364, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Actual364" "', argument " "1"" of type '" "QuantLib::Actual364 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Actual364 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Actual365Fixed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Actual365Fixed::Convention arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Actual365Fixed *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Actual365Fixed" "', argument " "1"" of type '" "QuantLib::Actual365Fixed::Convention""'");
  } 
  arg1 = static_cast< QuantLib::Actual365Fixed::Convention >(val1);
  {
    try {
      result = (QuantLib::Actual365Fixed *)new QuantLib::Actual365Fixed(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual365Fixed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual365Fixed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Actual365Fixed *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Actual365Fixed *)new QuantLib::Actual365Fixed();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Actual365Fixed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Actual365Fixed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Actual365Fixed", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Actual365Fixed__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Actual365Fixed__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Actual365Fixed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Actual365Fixed::Actual365Fixed(QuantLib::Actual365Fixed::Convention)\n"
    "    QuantLib::Actual365Fixed::Actual365Fixed()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Actual365Fixed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Actual365Fixed *arg1 = (QuantLib::Actual365Fixed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Actual365Fixed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Actual365Fixed" "', argument " "1"" of type '" "QuantLib::Actual365Fixed *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Actual365Fixed * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Thirty360__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Thirty360::Convention arg1 ;
  Date *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  QuantLib::Thirty360 *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Thirty360" "', argument " "1"" of type '" "QuantLib::Thirty360::Convention""'");
  } 
  arg1 = static_cast< QuantLib::Thirty360::Convention >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Thirty360" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Thirty360" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (QuantLib::Thirty360 *)new QuantLib::Thirty360(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Thirty360, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Thirty360__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::Thirty360::Convention arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::Thirty360 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Thirty360" "', argument " "1"" of type '" "QuantLib::Thirty360::Convention""'");
  } 
  arg1 = static_cast< QuantLib::Thirty360::Convention >(val1);
  {
    try {
      result = (QuantLib::Thirty360 *)new QuantLib::Thirty360(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Thirty360, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Thirty360(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Thirty360", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Thirty360__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Thirty360__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Thirty360'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Thirty360::Thirty360(QuantLib::Thirty360::Convention,Date const &)\n"
    "    QuantLib::Thirty360::Thirty360(QuantLib::Thirty360::Convention)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Thirty360(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Thirty360 *arg1 = (QuantLib::Thirty360 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Thirty360, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Thirty360" "', argument " "1"" of type '" "QuantLib::Thirty360 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Thirty360 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Thirty365(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Thirty365 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Thirty365", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Thirty365 *)new QuantLib::Thirty365();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Thirty365, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Thirty365(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Thirty365 *arg1 = (QuantLib::Thirty365 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Thirty365, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Thirty365" "', argument " "1"" of type '" "QuantLib::Thirty365 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Thirty365 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ActualActual__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::ActualActual::Convention arg1 ;
  Schedule *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  QuantLib::ActualActual *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActualActual" "', argument " "1"" of type '" "QuantLib::ActualActual::Convention""'");
  } 
  arg1 = static_cast< QuantLib::ActualActual::Convention >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ActualActual" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ActualActual" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    try {
      result = (QuantLib::ActualActual *)new QuantLib::ActualActual(arg1,(Schedule const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ActualActual, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ActualActual__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  QuantLib::ActualActual::Convention arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  QuantLib::ActualActual *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActualActual" "', argument " "1"" of type '" "QuantLib::ActualActual::Convention""'");
  } 
  arg1 = static_cast< QuantLib::ActualActual::Convention >(val1);
  {
    try {
      result = (QuantLib::ActualActual *)new QuantLib::ActualActual(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ActualActual, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ActualActual(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ActualActual", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ActualActual__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ActualActual__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ActualActual'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::ActualActual::ActualActual(QuantLib::ActualActual::Convention,Schedule const &)\n"
    "    QuantLib::ActualActual::ActualActual(QuantLib::ActualActual::Convention)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ActualActual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ActualActual *arg1 = (QuantLib::ActualActual *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ActualActual, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ActualActual" "', argument " "1"" of type '" "QuantLib::ActualActual *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ActualActual * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_OneDayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::OneDayCounter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_OneDayCounter", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::OneDayCounter *)new QuantLib::OneDayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__OneDayCounter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OneDayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::OneDayCounter *arg1 = (QuantLib::OneDayCounter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__OneDayCounter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OneDayCounter" "', argument " "1"" of type '" "QuantLib::OneDayCounter *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::OneDayCounter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SimpleDayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SimpleDayCounter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SimpleDayCounter", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SimpleDayCounter *)new QuantLib::SimpleDayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SimpleDayCounter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SimpleDayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SimpleDayCounter *arg1 = (QuantLib::SimpleDayCounter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SimpleDayCounter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleDayCounter" "', argument " "1"" of type '" "QuantLib::SimpleDayCounter *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SimpleDayCounter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Business252__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< Calendar > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  QuantLib::Business252 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Business252" "', argument " "1"" of type '" "Calendar""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Business252" "', argument " "1"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (QuantLib::Business252 *)new QuantLib::Business252(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Business252, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Business252__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  QuantLib::Business252 *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::Business252 *)new QuantLib::Business252();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__Business252, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Business252(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Business252", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Business252__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Business252__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Business252'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QuantLib::Business252::Business252(Calendar)\n"
    "    QuantLib::Business252::Business252()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Business252(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::Business252 *arg1 = (QuantLib::Business252 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__Business252, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Business252" "', argument " "1"" of type '" "QuantLib::Business252 *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::Business252 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_yearFractionToDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DayCounter *arg1 = 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "yearFractionToDate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "yearFractionToDate" "', argument " "1"" of type '" "DayCounter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yearFractionToDate" "', argument " "1"" of type '" "DayCounter const &""'"); 
  }
  arg1 = reinterpret_cast< DayCounter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "yearFractionToDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yearFractionToDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "yearFractionToDate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = yearFractionToDate((DayCounter const &)*arg1,(Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Rounding *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Rounding", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Rounding *)new Rounding();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Rounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rounding___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Rounding *arg1 = (Rounding *) 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Decimal result;
  
  if (!SWIG_Python_UnpackTuple(args, "Rounding___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rounding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rounding___call__" "', argument " "1"" of type '" "Rounding const *""'"); 
  }
  arg1 = reinterpret_cast< Rounding * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rounding___call__" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = (Decimal)((Rounding const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Rounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Rounding *arg1 = (Rounding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Rounding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rounding" "', argument " "1"" of type '" "Rounding *""'"); 
  }
  arg1 = reinterpret_cast< Rounding * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UpRounding__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Integer arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  UpRounding *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpRounding" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpRounding" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (UpRounding *)new UpRounding(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UpRounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpRounding__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  UpRounding *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpRounding" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (UpRounding *)new UpRounding(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UpRounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpRounding(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UpRounding", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UpRounding__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UpRounding__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UpRounding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UpRounding::UpRounding(Integer,Integer)\n"
    "    UpRounding::UpRounding(Integer)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UpRounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UpRounding *arg1 = (UpRounding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UpRounding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UpRounding" "', argument " "1"" of type '" "UpRounding *""'"); 
  }
  arg1 = reinterpret_cast< UpRounding * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DownRounding__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Integer arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  DownRounding *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DownRounding" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DownRounding" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (DownRounding *)new DownRounding(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DownRounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DownRounding__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  DownRounding *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DownRounding" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (DownRounding *)new DownRounding(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DownRounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DownRounding(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DownRounding", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DownRounding__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DownRounding__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DownRounding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DownRounding::DownRounding(Integer,Integer)\n"
    "    DownRounding::DownRounding(Integer)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DownRounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DownRounding *arg1 = (DownRounding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DownRounding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DownRounding" "', argument " "1"" of type '" "DownRounding *""'"); 
  }
  arg1 = reinterpret_cast< DownRounding * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ClosestRounding__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Integer arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ClosestRounding *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClosestRounding" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClosestRounding" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (ClosestRounding *)new ClosestRounding(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ClosestRounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClosestRounding__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  ClosestRounding *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClosestRounding" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (ClosestRounding *)new ClosestRounding(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ClosestRounding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClosestRounding(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ClosestRounding", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ClosestRounding__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ClosestRounding__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ClosestRounding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ClosestRounding::ClosestRounding(Integer,Integer)\n"
    "    ClosestRounding::ClosestRounding(Integer)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClosestRounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ClosestRounding *arg1 = (ClosestRounding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ClosestRounding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClosestRounding" "', argument " "1"" of type '" "ClosestRounding *""'"); 
  }
  arg1 = reinterpret_cast< ClosestRounding * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CeilingTruncation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Integer arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  CeilingTruncation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CeilingTruncation" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CeilingTruncation" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (CeilingTruncation *)new CeilingTruncation(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CeilingTruncation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CeilingTruncation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  CeilingTruncation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CeilingTruncation" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (CeilingTruncation *)new CeilingTruncation(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CeilingTruncation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CeilingTruncation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CeilingTruncation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CeilingTruncation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CeilingTruncation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CeilingTruncation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CeilingTruncation::CeilingTruncation(Integer,Integer)\n"
    "    CeilingTruncation::CeilingTruncation(Integer)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CeilingTruncation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CeilingTruncation *arg1 = (CeilingTruncation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CeilingTruncation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CeilingTruncation" "', argument " "1"" of type '" "CeilingTruncation *""'"); 
  }
  arg1 = reinterpret_cast< CeilingTruncation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FloorTruncation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Integer arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FloorTruncation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloorTruncation" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloorTruncation" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (FloorTruncation *)new FloorTruncation(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloorTruncation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloorTruncation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  FloorTruncation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloorTruncation" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (FloorTruncation *)new FloorTruncation(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FloorTruncation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloorTruncation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FloorTruncation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FloorTruncation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FloorTruncation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FloorTruncation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FloorTruncation::FloorTruncation(Integer,Integer)\n"
    "    FloorTruncation::FloorTruncation(Integer)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FloorTruncation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloorTruncation *arg1 = (FloorTruncation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FloorTruncation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloorTruncation" "', argument " "1"" of type '" "FloorTruncation *""'"); 
  }
  arg1 = reinterpret_cast< FloorTruncation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_Currency__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Currency *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Currency *)new Currency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Integer arg3 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  Integer arg6 ;
  Rounding *arg7 = 0 ;
  std::string *arg8 = 0 ;
  Currency *arg9 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  Currency *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Currency" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Currency" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Currency" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Currency" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Currency" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Currency" "', argument " "6"" of type '" "Integer""'");
  } 
  arg6 = static_cast< Integer >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Rounding,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Currency" "', argument " "7"" of type '" "Rounding const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "7"" of type '" "Rounding const &""'"); 
  }
  arg7 = reinterpret_cast< Rounding * >(argp7);
  {
    std::string *ptr = (std::string *)0;
    res8 = SWIG_AsPtr_std_string(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Currency" "', argument " "8"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "8"" of type '" "std::string const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Currency" "', argument " "9"" of type '" "Currency const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "9"" of type '" "Currency const &""'"); 
  }
  arg9 = reinterpret_cast< Currency * >(argp9);
  {
    try {
      result = (Currency *)new Currency((std::string const &)*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,(Rounding const &)*arg7,(std::string const &)*arg8,(Currency const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  Integer arg3 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  Integer arg6 ;
  Rounding *arg7 = 0 ;
  std::string *arg8 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  Currency *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Currency" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Currency" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Currency" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Currency" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Currency" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Currency" "', argument " "6"" of type '" "Integer""'");
  } 
  arg6 = static_cast< Integer >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Rounding,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Currency" "', argument " "7"" of type '" "Rounding const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "7"" of type '" "Rounding const &""'"); 
  }
  arg7 = reinterpret_cast< Rounding * >(argp7);
  {
    std::string *ptr = (std::string *)0;
    res8 = SWIG_AsPtr_std_string(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Currency" "', argument " "8"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "8"" of type '" "std::string const &""'"); 
    }
    arg8 = ptr;
  }
  {
    try {
      result = (Currency *)new Currency((std::string const &)*arg1,(std::string const &)*arg2,arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,(Rounding const &)*arg7,(std::string const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Currency", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Currency__SWIG_0(self, argc, argv);
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Rounding, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_Currency__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Rounding, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_Currency__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Currency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Currency::Currency()\n"
    "    Currency::Currency(std::string const &,std::string const &,Integer,std::string const &,std::string const &,Integer,Rounding const &,std::string const &,Currency const &)\n"
    "    Currency::Currency(std::string const &,std::string const &,Integer,std::string const &,std::string const &,Integer,Rounding const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Currency_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_name" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->name();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_code(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_code" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->code();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_numericCode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_numericCode" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (Integer)((Currency const *)arg1)->numericCode();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_symbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_symbol" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->symbol();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_fractionSymbol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_fractionSymbol" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (std::string *) &((Currency const *)arg1)->fractionSymbol();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_fractionsPerUnit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_fractionsPerUnit" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (Integer)((Currency const *)arg1)->fractionsPerUnit();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_rounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Rounding *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_rounding" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (Rounding *) &((Currency const *)arg1)->rounding();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Rounding, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_format(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_format" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = ((Currency const *)arg1)->format();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_empty" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (bool)((Currency const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency_triangulationCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Currency *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency_triangulationCurrency" "', argument " "1"" of type '" "Currency const *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (Currency *) &((Currency const *)arg1)->triangulationCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___str__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = Currency___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  Currency *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Currency___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___eq__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Currency___eq__" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Currency___eq__" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  arg2 = reinterpret_cast< Currency * >(argp2);
  {
    try {
      result = (bool)Currency___eq__(arg1,(Currency const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Currency___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  Currency *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Currency___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___ne__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Currency___ne__" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Currency___ne__" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  arg2 = reinterpret_cast< Currency * >(argp2);
  {
    try {
      result = (bool)Currency___ne__(arg1,(Currency const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Currency___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Currency___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___mul__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Currency___mul__" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = Currency_operator_Sm_(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Currency___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Currency___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___rmul__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Currency___rmul__" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = Currency___rmul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Currency___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___nonzero__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (bool)Currency___nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Currency___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Currency___bool__" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      result = (bool)Currency___bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Currency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = (Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Currency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Currency" "', argument " "1"" of type '" "Currency *""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_AEDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::AEDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AEDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::AEDCurrency *)new QuantLib::AEDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__AEDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AEDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::AEDCurrency *arg1 = (QuantLib::AEDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__AEDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AEDCurrency" "', argument " "1"" of type '" "QuantLib::AEDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::AEDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_AOACurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::AOACurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AOACurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::AOACurrency *)new QuantLib::AOACurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__AOACurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AOACurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::AOACurrency *arg1 = (QuantLib::AOACurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__AOACurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AOACurrency" "', argument " "1"" of type '" "QuantLib::AOACurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::AOACurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ARSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ARSCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ARSCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ARSCurrency *)new QuantLib::ARSCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ARSCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ARSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ARSCurrency *arg1 = (QuantLib::ARSCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ARSCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ARSCurrency" "', argument " "1"" of type '" "QuantLib::ARSCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ARSCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ATSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ATSCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ATSCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ATSCurrency *)new QuantLib::ATSCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ATSCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ATSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ATSCurrency *arg1 = (QuantLib::ATSCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ATSCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ATSCurrency" "', argument " "1"" of type '" "QuantLib::ATSCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ATSCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_AUDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::AUDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AUDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::AUDCurrency *)new QuantLib::AUDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__AUDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AUDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::AUDCurrency *arg1 = (QuantLib::AUDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__AUDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AUDCurrency" "', argument " "1"" of type '" "QuantLib::AUDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::AUDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BDTCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BDTCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BDTCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BDTCurrency *)new QuantLib::BDTCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BDTCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BDTCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BDTCurrency *arg1 = (QuantLib::BDTCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BDTCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BDTCurrency" "', argument " "1"" of type '" "QuantLib::BDTCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BDTCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BEFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BEFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BEFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BEFCurrency *)new QuantLib::BEFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BEFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BEFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BEFCurrency *arg1 = (QuantLib::BEFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BEFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BEFCurrency" "', argument " "1"" of type '" "QuantLib::BEFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BEFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BHDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BHDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BHDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BHDCurrency *)new QuantLib::BHDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BHDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BHDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BHDCurrency *arg1 = (QuantLib::BHDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BHDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BHDCurrency" "', argument " "1"" of type '" "QuantLib::BHDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BHDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BGLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BGLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BGLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BGLCurrency *)new QuantLib::BGLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BGLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BGLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BGLCurrency *arg1 = (QuantLib::BGLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BGLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BGLCurrency" "', argument " "1"" of type '" "QuantLib::BGLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BGLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BGNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BGNCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BGNCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BGNCurrency *)new QuantLib::BGNCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BGNCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BGNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BGNCurrency *arg1 = (QuantLib::BGNCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BGNCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BGNCurrency" "', argument " "1"" of type '" "QuantLib::BGNCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BGNCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BRLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BRLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BRLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BRLCurrency *)new QuantLib::BRLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BRLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BRLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BRLCurrency *arg1 = (QuantLib::BRLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BRLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BRLCurrency" "', argument " "1"" of type '" "QuantLib::BRLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BRLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BWPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BWPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BWPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BWPCurrency *)new QuantLib::BWPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BWPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BWPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BWPCurrency *arg1 = (QuantLib::BWPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BWPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BWPCurrency" "', argument " "1"" of type '" "QuantLib::BWPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BWPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BYRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BYRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BYRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BYRCurrency *)new QuantLib::BYRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BYRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BYRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BYRCurrency *arg1 = (QuantLib::BYRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BYRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BYRCurrency" "', argument " "1"" of type '" "QuantLib::BYRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BYRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CADCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CADCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CADCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CADCurrency *)new QuantLib::CADCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CADCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CADCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CADCurrency *arg1 = (QuantLib::CADCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CADCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CADCurrency" "', argument " "1"" of type '" "QuantLib::CADCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CADCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CHFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CHFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CHFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CHFCurrency *)new QuantLib::CHFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CHFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CHFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CHFCurrency *arg1 = (QuantLib::CHFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CHFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CHFCurrency" "', argument " "1"" of type '" "QuantLib::CHFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CHFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CLFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CLFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CLFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CLFCurrency *)new QuantLib::CLFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CLFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CLFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CLFCurrency *arg1 = (QuantLib::CLFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CLFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CLFCurrency" "', argument " "1"" of type '" "QuantLib::CLFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CLFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CLPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CLPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CLPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CLPCurrency *)new QuantLib::CLPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CLPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CLPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CLPCurrency *arg1 = (QuantLib::CLPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CLPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CLPCurrency" "', argument " "1"" of type '" "QuantLib::CLPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CLPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CNHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CNHCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CNHCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CNHCurrency *)new QuantLib::CNHCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CNHCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CNHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CNHCurrency *arg1 = (QuantLib::CNHCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CNHCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CNHCurrency" "', argument " "1"" of type '" "QuantLib::CNHCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CNHCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CNYCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CNYCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CNYCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CNYCurrency *)new QuantLib::CNYCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CNYCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CNYCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CNYCurrency *arg1 = (QuantLib::CNYCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CNYCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CNYCurrency" "', argument " "1"" of type '" "QuantLib::CNYCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CNYCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_COPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::COPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_COPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::COPCurrency *)new QuantLib::COPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__COPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_COPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::COPCurrency *arg1 = (QuantLib::COPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__COPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_COPCurrency" "', argument " "1"" of type '" "QuantLib::COPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::COPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_COUCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::COUCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_COUCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::COUCurrency *)new QuantLib::COUCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__COUCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_COUCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::COUCurrency *arg1 = (QuantLib::COUCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__COUCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_COUCurrency" "', argument " "1"" of type '" "QuantLib::COUCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::COUCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CYPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CYPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CYPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CYPCurrency *)new QuantLib::CYPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CYPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CYPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CYPCurrency *arg1 = (QuantLib::CYPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CYPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CYPCurrency" "', argument " "1"" of type '" "QuantLib::CYPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CYPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_CZKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CZKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CZKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::CZKCurrency *)new QuantLib::CZKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__CZKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CZKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::CZKCurrency *arg1 = (QuantLib::CZKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__CZKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CZKCurrency" "', argument " "1"" of type '" "QuantLib::CZKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::CZKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DEMCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::DEMCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DEMCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::DEMCurrency *)new QuantLib::DEMCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__DEMCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DEMCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::DEMCurrency *arg1 = (QuantLib::DEMCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__DEMCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DEMCurrency" "', argument " "1"" of type '" "QuantLib::DEMCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::DEMCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_DKKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::DKKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DKKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::DKKCurrency *)new QuantLib::DKKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__DKKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DKKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::DKKCurrency *arg1 = (QuantLib::DKKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__DKKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DKKCurrency" "', argument " "1"" of type '" "QuantLib::DKKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::DKKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_EEKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::EEKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EEKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::EEKCurrency *)new QuantLib::EEKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__EEKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EEKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::EEKCurrency *arg1 = (QuantLib::EEKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__EEKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EEKCurrency" "', argument " "1"" of type '" "QuantLib::EEKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::EEKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_EGPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::EGPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EGPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::EGPCurrency *)new QuantLib::EGPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__EGPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EGPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::EGPCurrency *arg1 = (QuantLib::EGPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__EGPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EGPCurrency" "', argument " "1"" of type '" "QuantLib::EGPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::EGPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ESPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ESPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ESPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ESPCurrency *)new QuantLib::ESPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ESPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ESPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ESPCurrency *arg1 = (QuantLib::ESPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ESPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ESPCurrency" "', argument " "1"" of type '" "QuantLib::ESPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ESPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ETBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ETBCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ETBCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ETBCurrency *)new QuantLib::ETBCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ETBCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ETBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ETBCurrency *arg1 = (QuantLib::ETBCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ETBCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ETBCurrency" "', argument " "1"" of type '" "QuantLib::ETBCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ETBCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_EURCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::EURCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EURCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::EURCurrency *)new QuantLib::EURCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__EURCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EURCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::EURCurrency *arg1 = (QuantLib::EURCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__EURCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURCurrency" "', argument " "1"" of type '" "QuantLib::EURCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::EURCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FIMCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::FIMCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FIMCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::FIMCurrency *)new QuantLib::FIMCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__FIMCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FIMCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::FIMCurrency *arg1 = (QuantLib::FIMCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__FIMCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FIMCurrency" "', argument " "1"" of type '" "QuantLib::FIMCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::FIMCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_FRFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::FRFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FRFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::FRFCurrency *)new QuantLib::FRFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__FRFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FRFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::FRFCurrency *arg1 = (QuantLib::FRFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__FRFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FRFCurrency" "', argument " "1"" of type '" "QuantLib::FRFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::FRFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_GELCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GELCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GELCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::GELCurrency *)new QuantLib::GELCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__GELCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GELCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GELCurrency *arg1 = (QuantLib::GELCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__GELCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GELCurrency" "', argument " "1"" of type '" "QuantLib::GELCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::GELCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_GBPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GBPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GBPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::GBPCurrency *)new QuantLib::GBPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__GBPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GBPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GBPCurrency *arg1 = (QuantLib::GBPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__GBPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPCurrency" "', argument " "1"" of type '" "QuantLib::GBPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::GBPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_GHSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GHSCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GHSCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::GHSCurrency *)new QuantLib::GHSCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__GHSCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GHSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GHSCurrency *arg1 = (QuantLib::GHSCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__GHSCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GHSCurrency" "', argument " "1"" of type '" "QuantLib::GHSCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::GHSCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_GRDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GRDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GRDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::GRDCurrency *)new QuantLib::GRDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__GRDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GRDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::GRDCurrency *arg1 = (QuantLib::GRDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__GRDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GRDCurrency" "', argument " "1"" of type '" "QuantLib::GRDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::GRDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_HKDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HKDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HKDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::HKDCurrency *)new QuantLib::HKDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__HKDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HKDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HKDCurrency *arg1 = (QuantLib::HKDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__HKDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HKDCurrency" "', argument " "1"" of type '" "QuantLib::HKDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::HKDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_HRKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HRKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HRKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::HRKCurrency *)new QuantLib::HRKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__HRKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HRKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HRKCurrency *arg1 = (QuantLib::HRKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__HRKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HRKCurrency" "', argument " "1"" of type '" "QuantLib::HRKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::HRKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_HUFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HUFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HUFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::HUFCurrency *)new QuantLib::HUFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__HUFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HUFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::HUFCurrency *arg1 = (QuantLib::HUFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__HUFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HUFCurrency" "', argument " "1"" of type '" "QuantLib::HUFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::HUFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IDRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IDRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IDRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::IDRCurrency *)new QuantLib::IDRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__IDRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IDRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IDRCurrency *arg1 = (QuantLib::IDRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__IDRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IDRCurrency" "', argument " "1"" of type '" "QuantLib::IDRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::IDRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IEPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IEPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IEPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::IEPCurrency *)new QuantLib::IEPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__IEPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IEPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IEPCurrency *arg1 = (QuantLib::IEPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__IEPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IEPCurrency" "', argument " "1"" of type '" "QuantLib::IEPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::IEPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ILSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ILSCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ILSCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ILSCurrency *)new QuantLib::ILSCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ILSCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ILSCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ILSCurrency *arg1 = (QuantLib::ILSCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ILSCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ILSCurrency" "', argument " "1"" of type '" "QuantLib::ILSCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ILSCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_INRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::INRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_INRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::INRCurrency *)new QuantLib::INRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__INRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_INRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::INRCurrency *arg1 = (QuantLib::INRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__INRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_INRCurrency" "', argument " "1"" of type '" "QuantLib::INRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::INRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IQDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IQDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IQDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::IQDCurrency *)new QuantLib::IQDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__IQDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IQDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IQDCurrency *arg1 = (QuantLib::IQDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__IQDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IQDCurrency" "', argument " "1"" of type '" "QuantLib::IQDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::IQDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_IRRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IRRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IRRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::IRRCurrency *)new QuantLib::IRRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__IRRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IRRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::IRRCurrency *arg1 = (QuantLib::IRRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__IRRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IRRCurrency" "', argument " "1"" of type '" "QuantLib::IRRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::IRRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ISKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ISKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ISKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ISKCurrency *)new QuantLib::ISKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ISKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ISKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ISKCurrency *arg1 = (QuantLib::ISKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ISKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ISKCurrency" "', argument " "1"" of type '" "QuantLib::ISKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ISKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ITLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ITLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ITLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ITLCurrency *)new QuantLib::ITLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ITLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ITLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ITLCurrency *arg1 = (QuantLib::ITLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ITLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ITLCurrency" "', argument " "1"" of type '" "QuantLib::ITLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ITLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_JODCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::JODCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_JODCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::JODCurrency *)new QuantLib::JODCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JODCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JODCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::JODCurrency *arg1 = (QuantLib::JODCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__JODCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JODCurrency" "', argument " "1"" of type '" "QuantLib::JODCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::JODCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_JPYCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::JPYCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_JPYCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::JPYCurrency *)new QuantLib::JPYCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__JPYCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JPYCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::JPYCurrency *arg1 = (QuantLib::JPYCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__JPYCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JPYCurrency" "', argument " "1"" of type '" "QuantLib::JPYCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::JPYCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_KESCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KESCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KESCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::KESCurrency *)new QuantLib::KESCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__KESCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KESCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KESCurrency *arg1 = (QuantLib::KESCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__KESCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KESCurrency" "', argument " "1"" of type '" "QuantLib::KESCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::KESCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_KRWCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KRWCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KRWCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::KRWCurrency *)new QuantLib::KRWCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__KRWCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KRWCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KRWCurrency *arg1 = (QuantLib::KRWCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__KRWCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KRWCurrency" "', argument " "1"" of type '" "QuantLib::KRWCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::KRWCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_KWDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KWDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KWDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::KWDCurrency *)new QuantLib::KWDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__KWDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KWDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KWDCurrency *arg1 = (QuantLib::KWDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__KWDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KWDCurrency" "', argument " "1"" of type '" "QuantLib::KWDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::KWDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_KZTCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KZTCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KZTCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::KZTCurrency *)new QuantLib::KZTCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__KZTCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KZTCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::KZTCurrency *arg1 = (QuantLib::KZTCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__KZTCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KZTCurrency" "', argument " "1"" of type '" "QuantLib::KZTCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::KZTCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LKRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LKRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LKRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::LKRCurrency *)new QuantLib::LKRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__LKRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LKRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LKRCurrency *arg1 = (QuantLib::LKRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__LKRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LKRCurrency" "', argument " "1"" of type '" "QuantLib::LKRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::LKRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LTLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LTLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LTLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::LTLCurrency *)new QuantLib::LTLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__LTLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LTLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LTLCurrency *arg1 = (QuantLib::LTLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__LTLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LTLCurrency" "', argument " "1"" of type '" "QuantLib::LTLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::LTLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LUFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LUFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LUFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::LUFCurrency *)new QuantLib::LUFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__LUFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LUFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LUFCurrency *arg1 = (QuantLib::LUFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__LUFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LUFCurrency" "', argument " "1"" of type '" "QuantLib::LUFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::LUFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_LVLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LVLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LVLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::LVLCurrency *)new QuantLib::LVLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__LVLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LVLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LVLCurrency *arg1 = (QuantLib::LVLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__LVLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LVLCurrency" "', argument " "1"" of type '" "QuantLib::LVLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::LVLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MADCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MADCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MADCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::MADCurrency *)new QuantLib::MADCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__MADCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MADCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MADCurrency *arg1 = (QuantLib::MADCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__MADCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MADCurrency" "', argument " "1"" of type '" "QuantLib::MADCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::MADCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MTLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MTLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MTLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::MTLCurrency *)new QuantLib::MTLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__MTLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MTLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MTLCurrency *arg1 = (QuantLib::MTLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__MTLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MTLCurrency" "', argument " "1"" of type '" "QuantLib::MTLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::MTLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MURCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MURCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MURCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::MURCurrency *)new QuantLib::MURCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__MURCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MURCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MURCurrency *arg1 = (QuantLib::MURCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__MURCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MURCurrency" "', argument " "1"" of type '" "QuantLib::MURCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::MURCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MXNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MXNCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MXNCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::MXNCurrency *)new QuantLib::MXNCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__MXNCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MXNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MXNCurrency *arg1 = (QuantLib::MXNCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__MXNCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MXNCurrency" "', argument " "1"" of type '" "QuantLib::MXNCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::MXNCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MXVCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MXVCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MXVCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::MXVCurrency *)new QuantLib::MXVCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__MXVCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MXVCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MXVCurrency *arg1 = (QuantLib::MXVCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__MXVCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MXVCurrency" "', argument " "1"" of type '" "QuantLib::MXVCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::MXVCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_MYRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MYRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MYRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::MYRCurrency *)new QuantLib::MYRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__MYRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MYRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::MYRCurrency *arg1 = (QuantLib::MYRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__MYRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MYRCurrency" "', argument " "1"" of type '" "QuantLib::MYRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::MYRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NGNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NGNCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NGNCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NGNCurrency *)new QuantLib::NGNCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NGNCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NGNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NGNCurrency *arg1 = (QuantLib::NGNCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NGNCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NGNCurrency" "', argument " "1"" of type '" "QuantLib::NGNCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NGNCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NLGCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NLGCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NLGCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NLGCurrency *)new QuantLib::NLGCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NLGCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NLGCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NLGCurrency *arg1 = (QuantLib::NLGCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NLGCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NLGCurrency" "', argument " "1"" of type '" "QuantLib::NLGCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NLGCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NOKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NOKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NOKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NOKCurrency *)new QuantLib::NOKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NOKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NOKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NOKCurrency *arg1 = (QuantLib::NOKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NOKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NOKCurrency" "', argument " "1"" of type '" "QuantLib::NOKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NOKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NPRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NPRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NPRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NPRCurrency *)new QuantLib::NPRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NPRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NPRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NPRCurrency *arg1 = (QuantLib::NPRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NPRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NPRCurrency" "', argument " "1"" of type '" "QuantLib::NPRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NPRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_NZDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NZDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NZDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::NZDCurrency *)new QuantLib::NZDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__NZDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NZDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::NZDCurrency *arg1 = (QuantLib::NZDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__NZDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NZDCurrency" "', argument " "1"" of type '" "QuantLib::NZDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::NZDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_OMRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::OMRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_OMRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::OMRCurrency *)new QuantLib::OMRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__OMRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OMRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::OMRCurrency *arg1 = (QuantLib::OMRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__OMRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OMRCurrency" "', argument " "1"" of type '" "QuantLib::OMRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::OMRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PEHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PEHCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PEHCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PEHCurrency *)new QuantLib::PEHCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PEHCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PEHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PEHCurrency *arg1 = (QuantLib::PEHCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PEHCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PEHCurrency" "', argument " "1"" of type '" "QuantLib::PEHCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PEHCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PEICurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PEICurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PEICurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PEICurrency *)new QuantLib::PEICurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PEICurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PEICurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PEICurrency *arg1 = (QuantLib::PEICurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PEICurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PEICurrency" "', argument " "1"" of type '" "QuantLib::PEICurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PEICurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PENCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PENCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PENCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PENCurrency *)new QuantLib::PENCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PENCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PENCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PENCurrency *arg1 = (QuantLib::PENCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PENCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PENCurrency" "', argument " "1"" of type '" "QuantLib::PENCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PENCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PHPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PHPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PHPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PHPCurrency *)new QuantLib::PHPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PHPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PHPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PHPCurrency *arg1 = (QuantLib::PHPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PHPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PHPCurrency" "', argument " "1"" of type '" "QuantLib::PHPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PHPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PKRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PKRCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PKRCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PKRCurrency *)new QuantLib::PKRCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PKRCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PKRCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PKRCurrency *arg1 = (QuantLib::PKRCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PKRCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PKRCurrency" "', argument " "1"" of type '" "QuantLib::PKRCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PKRCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PLNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PLNCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PLNCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PLNCurrency *)new QuantLib::PLNCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PLNCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PLNCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PLNCurrency *arg1 = (QuantLib::PLNCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PLNCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLNCurrency" "', argument " "1"" of type '" "QuantLib::PLNCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PLNCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_PTECurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PTECurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PTECurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::PTECurrency *)new QuantLib::PTECurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__PTECurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PTECurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::PTECurrency *arg1 = (QuantLib::PTECurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__PTECurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PTECurrency" "', argument " "1"" of type '" "QuantLib::PTECurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::PTECurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_QARCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::QARCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QARCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::QARCurrency *)new QuantLib::QARCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__QARCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QARCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::QARCurrency *arg1 = (QuantLib::QARCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__QARCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QARCurrency" "', argument " "1"" of type '" "QuantLib::QARCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::QARCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ROLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ROLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ROLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ROLCurrency *)new QuantLib::ROLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ROLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ROLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ROLCurrency *arg1 = (QuantLib::ROLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ROLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ROLCurrency" "', argument " "1"" of type '" "QuantLib::ROLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ROLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RONCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::RONCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RONCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::RONCurrency *)new QuantLib::RONCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__RONCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RONCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::RONCurrency *arg1 = (QuantLib::RONCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__RONCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RONCurrency" "', argument " "1"" of type '" "QuantLib::RONCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::RONCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RSDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::RSDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RSDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::RSDCurrency *)new QuantLib::RSDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__RSDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RSDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::RSDCurrency *arg1 = (QuantLib::RSDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__RSDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RSDCurrency" "', argument " "1"" of type '" "QuantLib::RSDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::RSDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_RUBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::RUBCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RUBCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::RUBCurrency *)new QuantLib::RUBCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__RUBCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RUBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::RUBCurrency *arg1 = (QuantLib::RUBCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__RUBCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RUBCurrency" "', argument " "1"" of type '" "QuantLib::RUBCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::RUBCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SARCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SARCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SARCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SARCurrency *)new QuantLib::SARCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SARCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SARCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SARCurrency *arg1 = (QuantLib::SARCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SARCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SARCurrency" "', argument " "1"" of type '" "QuantLib::SARCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SARCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SEKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SEKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SEKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SEKCurrency *)new QuantLib::SEKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SEKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SEKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SEKCurrency *arg1 = (QuantLib::SEKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SEKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SEKCurrency" "', argument " "1"" of type '" "QuantLib::SEKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SEKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SGDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SGDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SGDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SGDCurrency *)new QuantLib::SGDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SGDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SGDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SGDCurrency *arg1 = (QuantLib::SGDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SGDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SGDCurrency" "', argument " "1"" of type '" "QuantLib::SGDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SGDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SITCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SITCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SITCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SITCurrency *)new QuantLib::SITCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SITCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SITCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SITCurrency *arg1 = (QuantLib::SITCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SITCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SITCurrency" "', argument " "1"" of type '" "QuantLib::SITCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SITCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_SKKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SKKCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SKKCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::SKKCurrency *)new QuantLib::SKKCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__SKKCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SKKCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::SKKCurrency *arg1 = (QuantLib::SKKCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__SKKCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SKKCurrency" "', argument " "1"" of type '" "QuantLib::SKKCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::SKKCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_THBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::THBCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_THBCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::THBCurrency *)new QuantLib::THBCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__THBCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_THBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::THBCurrency *arg1 = (QuantLib::THBCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__THBCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_THBCurrency" "', argument " "1"" of type '" "QuantLib::THBCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::THBCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TNDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TNDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TNDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::TNDCurrency *)new QuantLib::TNDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__TNDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TNDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TNDCurrency *arg1 = (QuantLib::TNDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__TNDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TNDCurrency" "', argument " "1"" of type '" "QuantLib::TNDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::TNDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TRLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TRLCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TRLCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::TRLCurrency *)new QuantLib::TRLCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__TRLCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TRLCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TRLCurrency *arg1 = (QuantLib::TRLCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__TRLCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TRLCurrency" "', argument " "1"" of type '" "QuantLib::TRLCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::TRLCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TRYCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TRYCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TRYCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::TRYCurrency *)new QuantLib::TRYCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__TRYCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TRYCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TRYCurrency *arg1 = (QuantLib::TRYCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__TRYCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TRYCurrency" "', argument " "1"" of type '" "QuantLib::TRYCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::TRYCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TTDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TTDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TTDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::TTDCurrency *)new QuantLib::TTDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__TTDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TTDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TTDCurrency *arg1 = (QuantLib::TTDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__TTDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TTDCurrency" "', argument " "1"" of type '" "QuantLib::TTDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::TTDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_TWDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TWDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TWDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::TWDCurrency *)new QuantLib::TWDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__TWDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TWDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::TWDCurrency *arg1 = (QuantLib::TWDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__TWDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TWDCurrency" "', argument " "1"" of type '" "QuantLib::TWDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::TWDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UAHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UAHCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_UAHCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::UAHCurrency *)new QuantLib::UAHCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__UAHCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UAHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UAHCurrency *arg1 = (QuantLib::UAHCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__UAHCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UAHCurrency" "', argument " "1"" of type '" "QuantLib::UAHCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::UAHCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UGXCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UGXCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_UGXCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::UGXCurrency *)new QuantLib::UGXCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__UGXCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UGXCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UGXCurrency *arg1 = (QuantLib::UGXCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__UGXCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UGXCurrency" "', argument " "1"" of type '" "QuantLib::UGXCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::UGXCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_USDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::USDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_USDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::USDCurrency *)new QuantLib::USDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__USDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_USDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::USDCurrency *arg1 = (QuantLib::USDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__USDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_USDCurrency" "', argument " "1"" of type '" "QuantLib::USDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::USDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_UYUCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UYUCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_UYUCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::UYUCurrency *)new QuantLib::UYUCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__UYUCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UYUCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::UYUCurrency *arg1 = (QuantLib::UYUCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__UYUCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UYUCurrency" "', argument " "1"" of type '" "QuantLib::UYUCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::UYUCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_VEBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::VEBCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VEBCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::VEBCurrency *)new QuantLib::VEBCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__VEBCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VEBCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::VEBCurrency *arg1 = (QuantLib::VEBCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__VEBCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VEBCurrency" "', argument " "1"" of type '" "QuantLib::VEBCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::VEBCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_VNDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::VNDCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VNDCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::VNDCurrency *)new QuantLib::VNDCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__VNDCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VNDCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::VNDCurrency *arg1 = (QuantLib::VNDCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__VNDCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VNDCurrency" "', argument " "1"" of type '" "QuantLib::VNDCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::VNDCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_XOFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::XOFCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_XOFCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::XOFCurrency *)new QuantLib::XOFCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__XOFCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XOFCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::XOFCurrency *arg1 = (QuantLib::XOFCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__XOFCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XOFCurrency" "', argument " "1"" of type '" "QuantLib::XOFCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::XOFCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ZARCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ZARCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZARCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ZARCurrency *)new QuantLib::ZARCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ZARCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZARCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ZARCurrency *arg1 = (QuantLib::ZARCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ZARCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZARCurrency" "', argument " "1"" of type '" "QuantLib::ZARCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ZARCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_ZMWCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ZMWCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZMWCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ZMWCurrency *)new QuantLib::ZMWCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ZMWCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZMWCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ZMWCurrency *arg1 = (QuantLib::ZMWCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ZMWCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZMWCurrency" "', argument " "1"" of type '" "QuantLib::ZMWCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ZMWCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

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

SWIGINTERN PyObject *_wrap_new_BCHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BCHCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BCHCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BCHCurrency *)new QuantLib::BCHCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BCHCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BCHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BCHCurrency *arg1 = (QuantLib::BCHCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BCHCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BCHCurrency" "', argument " "1"" of type '" "QuantLib::BCHCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BCHCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *BCHCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BTCCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BTCCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BTCCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::BTCCurrency *)new QuantLib::BTCCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__BTCCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BTCCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::BTCCurrency *arg1 = (QuantLib::BTCCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__BTCCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BTCCurrency" "', argument " "1"" of type '" "QuantLib::BTCCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::BTCCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BTCCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__BTCCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BTCCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DASHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::DASHCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DASHCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::DASHCurrency *)new QuantLib::DASHCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__DASHCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DASHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::DASHCurrency *arg1 = (QuantLib::DASHCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__DASHCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DASHCurrency" "', argument " "1"" of type '" "QuantLib::DASHCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::DASHCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DASHCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__DASHCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DASHCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ETCCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ETCCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ETCCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ETCCurrency *)new QuantLib::ETCCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ETCCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ETCCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ETCCurrency *arg1 = (QuantLib::ETCCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ETCCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ETCCurrency" "', argument " "1"" of type '" "QuantLib::ETCCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ETCCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ETCCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__ETCCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ETCCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ETHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ETHCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ETHCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ETHCurrency *)new QuantLib::ETHCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ETHCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ETHCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ETHCurrency *arg1 = (QuantLib::ETHCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ETHCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ETHCurrency" "', argument " "1"" of type '" "QuantLib::ETHCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ETHCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ETHCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__ETHCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ETHCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LTCCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LTCCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LTCCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::LTCCurrency *)new QuantLib::LTCCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__LTCCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LTCCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::LTCCurrency *arg1 = (QuantLib::LTCCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__LTCCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LTCCurrency" "', argument " "1"" of type '" "QuantLib::LTCCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::LTCCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LTCCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__LTCCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LTCCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_XRPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::XRPCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_XRPCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::XRPCurrency *)new QuantLib::XRPCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__XRPCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_XRPCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::XRPCurrency *arg1 = (QuantLib::XRPCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__XRPCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XRPCurrency" "', argument " "1"" of type '" "QuantLib::XRPCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::XRPCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XRPCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__XRPCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *XRPCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZECCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ZECCurrency *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZECCurrency", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (QuantLib::ZECCurrency *)new QuantLib::ZECCurrency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_QuantLib__ZECCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZECCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantLib::ZECCurrency *arg1 = (QuantLib::ZECCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QuantLib__ZECCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZECCurrency" "', argument " "1"" of type '" "QuantLib::ZECCurrency *""'"); 
  }
  arg1 = reinterpret_cast< QuantLib::ZECCurrency * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZECCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_QuantLib__ZECCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZECCurrency_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InterestRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  InterestRate *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (InterestRate *)new InterestRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InterestRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InterestRate" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterestRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterestRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InterestRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_InterestRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = (InterestRate *)new InterestRate(arg1,(DayCounter const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InterestRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InterestRate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InterestRate__SWIG_0(self, argc, argv);
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_InterestRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InterestRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterestRate::InterestRate()\n"
    "    InterestRate::InterestRate(Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRate_rate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_rate" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  {
    try {
      result = (Rate)((InterestRate const *)arg1)->rate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_dayCounter" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  {
    try {
      result = ((InterestRate const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_compounding(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Compounding result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_compounding" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  {
    try {
      result = (Compounding)((InterestRate const *)arg1)->compounding();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_frequency" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  {
    try {
      result = (Frequency)((InterestRate const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_discountFactor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_discountFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_discountFactor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_discountFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRate_discountFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterestRate_discountFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_discountFactor" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_discountFactor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_discountFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRate_discountFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterestRate_discountFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_discountFactor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_discountFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRate_discountFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_discountFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (DiscountFactor)((InterestRate const *)arg1)->discountFactor((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_discountFactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRate_discountFactor", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InterestRate_discountFactor__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InterestRate_discountFactor__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InterestRate_discountFactor__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_InterestRate_discountFactor__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRate_discountFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterestRate::discountFactor(Time) const\n"
    "    InterestRate::discountFactor(Date const &,Date const &,Date const &,Date const &) const\n"
    "    InterestRate::discountFactor(Date const &,Date const &,Date const &) const\n"
    "    InterestRate::discountFactor(Date const &,Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRate_compoundFactor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_compoundFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_compoundFactor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_compoundFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRate_compoundFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterestRate_compoundFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_compoundFactor" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_compoundFactor__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_compoundFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRate_compoundFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterestRate_compoundFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor((Date const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_compoundFactor__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_compoundFactor" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRate_compoundFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_compoundFactor" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Real)((InterestRate const *)arg1)->compoundFactor((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_compoundFactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRate_compoundFactor", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InterestRate_compoundFactor__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InterestRate_compoundFactor__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InterestRate_compoundFactor__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_InterestRate_compoundFactor__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRate_compoundFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterestRate::compoundFactor(Time) const\n"
    "    InterestRate::compoundFactor(Date const &,Date const &,Date const &,Date const &) const\n"
    "    InterestRate::compoundFactor(Date const &,Date const &,Date const &) const\n"
    "    InterestRate::compoundFactor(Date const &,Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Time arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "InterestRate_impliedRate" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_impliedRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_impliedRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  Date *arg8 = 0 ;
  double 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 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  InterestRate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "InterestRate_impliedRate" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_impliedRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_impliedRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InterestRate_impliedRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "InterestRate_impliedRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "InterestRate_impliedRate" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  double 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 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterestRate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "InterestRate_impliedRate" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_impliedRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_impliedRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InterestRate_impliedRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "InterestRate_impliedRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  double 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 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "InterestRate_impliedRate" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_impliedRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_impliedRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InterestRate_impliedRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_impliedRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    try {
      result = InterestRate::impliedRate(arg1,(DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_impliedRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRate_impliedRate", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_InterestRate_impliedRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_InterestRate_impliedRate__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_InterestRate_impliedRate__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_InterestRate_impliedRate__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRate_impliedRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterestRate::impliedRate(Real,DayCounter const &,Compounding,Frequency,Time)\n"
    "    InterestRate::impliedRate(Real,DayCounter const &,Compounding,Frequency,Date const &,Date const &,Date const &,Date const &)\n"
    "    InterestRate::impliedRate(Real,DayCounter const &,Compounding,Frequency,Date const &,Date const &,Date const &)\n"
    "    InterestRate::impliedRate(Real,DayCounter const &,Compounding,Frequency,Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  Compounding arg2 ;
  Frequency arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_equivalentRate" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "Compounding""'");
  } 
  arg2 = static_cast< Compounding >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_equivalentRate" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_equivalentRate" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  Date *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  InterestRate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_equivalentRate" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_equivalentRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_equivalentRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_equivalentRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InterestRate_equivalentRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "InterestRate_equivalentRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "InterestRate_equivalentRate" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate((DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterestRate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_equivalentRate" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_equivalentRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_equivalentRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_equivalentRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InterestRate_equivalentRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "InterestRate_equivalentRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate((DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate_equivalentRate" "', argument " "1"" of type '" "InterestRate const *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRate_equivalentRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterestRate_equivalentRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InterestRate_equivalentRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InterestRate_equivalentRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRate_equivalentRate" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    try {
      result = ((InterestRate const *)arg1)->equivalentRate((DayCounter const &)*arg2,arg3,arg4,(Date const &)*arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRate_equivalentRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRate_equivalentRate", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InterestRate_equivalentRate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_InterestRate_equivalentRate__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_InterestRate_equivalentRate__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_InterestRate, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_InterestRate_equivalentRate__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRate_equivalentRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterestRate::equivalentRate(Compounding,Frequency,Time) const\n"
    "    InterestRate::equivalentRate(DayCounter const &,Compounding,Frequency,Date const &,Date const &,Date const &,Date const &) const\n"
    "    InterestRate::equivalentRate(DayCounter const &,Compounding,Frequency,Date const &,Date const &,Date const &) const\n"
    "    InterestRate::equivalentRate(DayCounter const &,Compounding,Frequency,Date const &,Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRate___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRate___str__" "', argument " "1"" of type '" "InterestRate *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  {
    try {
      result = InterestRate___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InterestRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRate *arg1 = (InterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InterestRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterestRate" "', argument " "1"" of type '" "InterestRate *""'"); 
  }
  arg1 = reinterpret_cast< InterestRate * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InterestRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InterestRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InterestRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_InterestRateVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_iterator" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_InterestRate_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___nonzero__" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_InterestRate_Sg____nonzero__((std::vector< InterestRate > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___bool__" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_InterestRate_Sg____bool__((std::vector< InterestRate > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___len__" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = std_vector_Sl_InterestRate_Sg____len__((std::vector< InterestRate > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  std::vector< InterestRate >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< InterestRate,std::allocator< InterestRate > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___getslice__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___getslice__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRateVector___getslice__" "', argument " "3"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< InterestRate >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< InterestRate,std::allocator< InterestRate > > *)std_vector_Sl_InterestRate_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  std::vector< InterestRate >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___setslice__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___setslice__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRateVector___setslice__" "', argument " "3"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< InterestRate >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  std::vector< InterestRate >::difference_type arg3 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___setslice__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___setslice__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRateVector___setslice__" "', argument " "3"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< InterestRate >::difference_type >(val3);
  {
    std::vector< InterestRate,std::allocator< InterestRate > > *ptr = (std::vector< InterestRate,std::allocator< InterestRate > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterestRateVector___setslice__" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector___setslice__" "', argument " "4"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InterestRateVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InterestRateVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::__setslice__(std::vector< InterestRate >::difference_type,std::vector< InterestRate >::difference_type)\n"
    "    std::vector< InterestRate >::__setslice__(std::vector< InterestRate >::difference_type,std::vector< InterestRate >::difference_type,std::vector< InterestRate,std::allocator< InterestRate > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  std::vector< InterestRate >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___delslice__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___delslice__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRateVector___delslice__" "', argument " "3"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< InterestRate >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___delitem__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___delitem__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___getitem__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< InterestRate,std::allocator< InterestRate > > *)std_vector_Sl_InterestRate_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< InterestRate,std::allocator< InterestRate > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___setitem__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< InterestRate,std::allocator< InterestRate > > *ptr = (std::vector< InterestRate,std::allocator< InterestRate > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRateVector___setitem__" "', argument " "3"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector___setitem__" "', argument " "3"" of type '" "std::vector< InterestRate,std::allocator< InterestRate > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< InterestRate,std::allocator< InterestRate > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___setitem__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___delitem__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_InterestRateVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InterestRateVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::__delitem__(std::vector< InterestRate >::difference_type)\n"
    "    std::vector< InterestRate >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< InterestRate >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___getitem__" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___getitem__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< InterestRate >::value_type *) &std_vector_Sl_InterestRate_Sg____getitem____SWIG_1((std::vector< InterestRate > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InterestRate, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< InterestRate >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_InterestRateVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InterestRateVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< InterestRate >::__getitem__(std::vector< InterestRate >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::difference_type arg2 ;
  std::vector< InterestRate >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector___setitem__" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector___setitem__" "', argument " "2"" of type '" "std::vector< InterestRate >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRateVector___setitem__" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector___setitem__" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_InterestRate_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(InterestRate const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_InterestRateVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InterestRateVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InterestRateVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< InterestRate,std::allocator< InterestRate > > const &)\n"
    "    std::vector< InterestRate >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< InterestRate >::__setitem__(std::vector< InterestRate >::difference_type,std::vector< InterestRate >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_pop" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_InterestRate_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< InterestRate >::value_type(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_append" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRateVector_append" "', argument " "2"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_append" "', argument " "2"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_InterestRate_Sg__append(arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestRateVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< InterestRate > *)new std::vector< InterestRate >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestRateVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< InterestRate > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< InterestRate,std::allocator< InterestRate > > *ptr = (std::vector< InterestRate,std::allocator< InterestRate > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterestRateVector" "', argument " "1"" of type '" "std::vector< InterestRate > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterestRateVector" "', argument " "1"" of type '" "std::vector< InterestRate > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< InterestRate > *)new std::vector< InterestRate >((std::vector< InterestRate > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_empty" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (bool)((std::vector< InterestRate > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_size" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = ((std::vector< InterestRate > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_swap" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRateVector_swap" "', argument " "2"" of type '" "std::vector< InterestRate > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_swap" "', argument " "2"" of type '" "std::vector< InterestRate > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< InterestRate > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_begin" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_end" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_rbegin" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_rend" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_clear" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< InterestRate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_get_allocator" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = ((std::vector< InterestRate > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< InterestRate >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_InterestRate_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestRateVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< InterestRate > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InterestRateVector" "', argument " "1"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg1 = static_cast< std::vector< InterestRate >::size_type >(val1);
  {
    try {
      result = (std::vector< InterestRate > *)new std::vector< InterestRate >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_pop_back" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_resize" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector_resize" "', argument " "2"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< InterestRate >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_erase" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_erase" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_erase" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_InterestRate_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::iterator arg2 ;
  std::vector< InterestRate >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< InterestRate >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_erase" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_erase" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_erase" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_erase" "', argument " "3"" of type '" "std::vector< InterestRate >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_erase" "', argument " "3"" of type '" "std::vector< InterestRate >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_InterestRate_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_InterestRateVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_InterestRateVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::erase(std::vector< InterestRate >::iterator)\n"
    "    std::vector< InterestRate >::erase(std::vector< InterestRate >::iterator,std::vector< InterestRate >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_InterestRateVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate >::size_type arg1 ;
  std::vector< InterestRate >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< InterestRate > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InterestRateVector" "', argument " "1"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg1 = static_cast< std::vector< InterestRate >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterestRateVector" "', argument " "2"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterestRateVector" "', argument " "2"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp2);
  {
    try {
      result = (std::vector< InterestRate > *)new std::vector< InterestRate >(arg1,(std::vector< InterestRate >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestRateVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InterestRateVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InterestRateVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InterestRateVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InterestRateVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InterestRateVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InterestRateVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::vector()\n"
    "    std::vector< InterestRate >::vector(std::vector< InterestRate > const &)\n"
    "    std::vector< InterestRate >::vector(std::vector< InterestRate >::size_type)\n"
    "    std::vector< InterestRate >::vector(std::vector< InterestRate >::size_type,std::vector< InterestRate >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_push_back" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRateVector_push_back" "', argument " "2"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_push_back" "', argument " "2"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< InterestRate >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_front" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (std::vector< InterestRate >::value_type *) &((std::vector< InterestRate > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InterestRate, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< InterestRate >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_back" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = (std::vector< InterestRate >::value_type *) &((std::vector< InterestRate > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InterestRate, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< InterestRate >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type arg2 ;
  std::vector< InterestRate >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_assign" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector_assign" "', argument " "2"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRateVector_assign" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_assign" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< InterestRate >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type arg2 ;
  std::vector< InterestRate >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_resize" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector_resize" "', argument " "2"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRateVector_resize" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_resize" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< InterestRate >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InterestRateVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InterestRateVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::resize(std::vector< InterestRate >::size_type)\n"
    "    std::vector< InterestRate >::resize(std::vector< InterestRate >::size_type,std::vector< InterestRate >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::iterator arg2 ;
  std::vector< InterestRate >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< InterestRate >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_insert" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_insert" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_insert" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterestRateVector_insert" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_insert" "', argument " "3"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_InterestRate_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(InterestRate const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< InterestRate >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::iterator arg2 ;
  std::vector< InterestRate >::size_type arg3 ;
  std::vector< InterestRate >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_insert" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_insert" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InterestRateVector_insert" "', argument " "2"" of type '" "std::vector< InterestRate >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterestRateVector_insert" "', argument " "3"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg3 = static_cast< std::vector< InterestRate >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterestRateVector_insert" "', argument " "4"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateVector_insert" "', argument " "4"" of type '" "std::vector< InterestRate >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< InterestRate >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_InterestRate_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(InterestRate const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InterestRateVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InterestRateVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< InterestRate,std::allocator< InterestRate > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< InterestRate >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InterestRateVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterestRateVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< InterestRate >::insert(std::vector< InterestRate >::iterator,std::vector< InterestRate >::value_type const &)\n"
    "    std::vector< InterestRate >::insert(std::vector< InterestRate >::iterator,std::vector< InterestRate >::size_type,std::vector< InterestRate >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  std::vector< InterestRate >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_reserve" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterestRateVector_reserve" "', argument " "2"" of type '" "std::vector< InterestRate >::size_type""'");
  } 
  arg2 = static_cast< std::vector< InterestRate >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< InterestRate >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateVector_capacity" "', argument " "1"" of type '" "std::vector< InterestRate > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      result = ((std::vector< InterestRate > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InterestRateVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< InterestRate > *arg1 = (std::vector< InterestRate > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterestRateVector" "', argument " "1"" of type '" "std::vector< InterestRate > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< InterestRate > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InterestRateVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_InterestRate_std__allocatorT_InterestRate_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InterestRateVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Observable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Observable *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Observable", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Observable *)new Observable();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Observable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Observable *arg1 = (Observable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Observable > tempshared1 ;
  ext::shared_ptr< Observable > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Observable_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Observable" "', argument " "1"" of type '" "Observable *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Observable > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Observable > * >(argp1);
      arg1 = const_cast< Observable * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Observable > * >(argp1);
      arg1 = const_cast< Observable * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Observable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Observable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Observer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  PyObserver *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      result = (PyObserver *)new PyObserver(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyObserver, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Observer__registerWith(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObserver *arg1 = (PyObserver *) 0 ;
  ext::shared_ptr< Observable > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Observable > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Observer__registerWith", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyObserver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observer__registerWith" "', argument " "1"" of type '" "PyObserver *""'"); 
  }
  arg1 = reinterpret_cast< PyObserver * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Observable_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Observer__registerWith" "', argument " "2"" of type '" "ext::shared_ptr< Observable > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Observable > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Observable > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Observable > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->registerWith((ext::shared_ptr< Observable > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Observer__unregisterWith(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObserver *arg1 = (PyObserver *) 0 ;
  ext::shared_ptr< Observable > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Observable > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Observer__unregisterWith", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyObserver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Observer__unregisterWith" "', argument " "1"" of type '" "PyObserver *""'"); 
  }
  arg1 = reinterpret_cast< PyObserver * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Observable_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Observer__unregisterWith" "', argument " "2"" of type '" "ext::shared_ptr< Observable > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Observable > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Observable > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Observable > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->unregisterWith((ext::shared_ptr< Observable > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Observer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObserver *arg1 = (PyObserver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyObserver, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Observer" "', argument " "1"" of type '" "PyObserver *""'"); 
  }
  arg1 = reinterpret_cast< PyObserver * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Observer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PyObserver, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Observer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Array__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Array *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Array *)new Array();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Array__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Array" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Array" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Array *)new Array(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Array__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  Array *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Array" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (Array *)new Array(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Array__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Array" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Array" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    try {
      result = (Array *)new Array((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Array(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Array", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Array__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Array__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      return _wrap_new_Array__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Array__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Array'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Array::Array()\n"
    "    Array::Array(Size,Real)\n"
    "    Array::Array(Size)\n"
    "    Array::Array(Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Array___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___len__" "', argument " "1"" of type '" "Array const *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    try {
      result = ((Array const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___str__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    try {
      result = Array___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___add__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Array___add__" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Array___add__" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = Array___add__(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___sub__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Array___sub__" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Array___sub__" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = Array___sub__(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___mul__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___mul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = Array___mul____SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___mul__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Array___mul__" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Array___mul__" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (Real)Array___mul____SWIG_1(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___mul____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___mul__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Array___mul__" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Array___mul__" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = Array___mul____SWIG_2(arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Array___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Array___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_Array___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          _v = 1;
          /* wrapped Matrix? */
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_Array___mul____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___div__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___div__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = Array___div__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___rmul__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___rmul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = Array___rmul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Array___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Integer arg2 ;
  Integer arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___getslice__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___getslice__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Array___getslice__" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  {
    try {
      result = Array___getslice__(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___setslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Integer arg2 ;
  Integer arg3 ;
  Array *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Array temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___setslice__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___setslice__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___setslice__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Array___setslice__" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  {
    if (ArrayFromSequence(swig_obj[3],&temp4)) {
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Array___setslice__" "', argument " "4"" of type '" "Array const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Array___setslice__" "', argument " "4"" of type '" "Array const &""'"); 
      }
      arg4 = reinterpret_cast< Array * >(argp4);
    }
  }
  {
    try {
      Array___setslice__(arg1,arg2,arg3,(Array const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___nonzero__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    try {
      result = (bool)Array___nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___bool__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    try {
      result = (bool)Array___bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___getitem__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (Real)Array___getitem__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Array___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  Integer arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Array___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Array___setitem__" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Array___setitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Array___setitem__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      Array___setitem__(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Array(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = (Array *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Array, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Array" "', argument " "1"" of type '" "Array *""'"); 
  }
  arg1 = reinterpret_cast< Array * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Array_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Array, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Array_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_MatrixRow___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MatrixRow *arg1 = (MatrixRow *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "MatrixRow___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MatrixRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixRow___getitem__" "', argument " "1"" of type '" "MatrixRow *""'"); 
  }
  arg1 = reinterpret_cast< MatrixRow * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixRow___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (Real)(arg1)->__getitem__(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatrixRow___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MatrixRow *arg1 = (MatrixRow *) 0 ;
  Integer arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MatrixRow___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MatrixRow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixRow___setitem__" "', argument " "1"" of type '" "MatrixRow *""'"); 
  }
  arg1 = reinterpret_cast< MatrixRow * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixRow___setitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixRow___setitem__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->__setitem__(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MatrixRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MatrixRow *arg1 = (MatrixRow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MatrixRow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatrixRow" "', argument " "1"" of type '" "MatrixRow *""'"); 
  }
  arg1 = reinterpret_cast< MatrixRow * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatrixRow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MatrixRow, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Matrix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Matrix *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Matrix *)new Matrix();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Matrix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Real arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Matrix *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Matrix" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Matrix *)new Matrix(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Matrix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Matrix *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Matrix" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Matrix *)new Matrix(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Matrix__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (PyTuple_Check(swig_obj[0]) || PyList_Check(swig_obj[0])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[0]) ?
      PyTuple_Size(swig_obj[0]) :
        PyList_Size(swig_obj[0]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[0],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp1 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[0],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp1[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp1[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix" "', argument " "1"" of type '" "Matrix const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix" "', argument " "1"" of type '" "Matrix const &""'"); 
      }
      arg1 = reinterpret_cast< Matrix * >(argp1);
    }
  }
  {
    try {
      result = (Matrix *)new Matrix((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Matrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Matrix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Matrix__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        _v = 1;
        /* wrapped Matrix? */
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      return _wrap_new_Matrix__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Matrix__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Matrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Matrix::Matrix()\n"
    "    Matrix::Matrix(Size,Size,Real)\n"
    "    Matrix::Matrix(Size,Size)\n"
    "    Matrix::Matrix(Matrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Matrix_rows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_rows" "', argument " "1"" of type '" "Matrix const *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    try {
      result = ((Matrix const *)arg1)->rows();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Matrix_columns(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_columns" "', argument " "1"" of type '" "Matrix const *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    try {
      result = ((Matrix const *)arg1)->columns();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Matrix___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___str__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    try {
      result = Matrix___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Matrix___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "Matrix___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___add__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix___add__" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix___add__" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = Matrix___add__(arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "Matrix___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___sub__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix___sub__" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix___sub__" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = Matrix___sub__(arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___mul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Matrix result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___mul__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix___mul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = Matrix___mul____SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___mul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___mul__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix___mul__" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix___mul__" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = Matrix___mul____SWIG_1(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___mul____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Matrix result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___mul__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix___mul__" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix___mul__" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = Matrix___mul____SWIG_2(arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Matrix___mul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix___mul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_Matrix___mul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          _v = 1;
          /* wrapped Matrix? */
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_Matrix___mul____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "Matrix___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___div__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix___div__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = Matrix___div__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< MatrixRow > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Matrix___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___getitem__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = Matrix___getitem__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new MatrixRow(result)), SWIGTYPE_p_MatrixRow, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Matrix___rmul____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Matrix result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___rmul__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix___rmul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = Matrix___rmul____SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___rmul____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___rmul__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix___rmul__" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix___rmul__" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = Matrix___rmul____SWIG_1(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___rmul____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Matrix result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix___rmul__" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix___rmul__" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix___rmul__" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = Matrix___rmul____SWIG_2(arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Matrix___rmul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Matrix___rmul__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix___rmul____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_Matrix___rmul____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Matrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          _v = 1;
          /* wrapped Matrix? */
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_Matrix___rmul____SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_Matrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = (Matrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Matrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix" "', argument " "1"" of type '" "Matrix *""'"); 
  }
  arg1 = reinterpret_cast< Matrix * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Matrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Matrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Matrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SalvagingAlgorithm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SalvagingAlgorithm *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SalvagingAlgorithm", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (SalvagingAlgorithm *)new SalvagingAlgorithm();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SalvagingAlgorithm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SalvagingAlgorithm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SalvagingAlgorithm *arg1 = (SalvagingAlgorithm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SalvagingAlgorithm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SalvagingAlgorithm" "', argument " "1"" of type '" "SalvagingAlgorithm *""'"); 
  }
  arg1 = reinterpret_cast< SalvagingAlgorithm * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SalvagingAlgorithm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SalvagingAlgorithm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SalvagingAlgorithm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_inverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyTuple_Check(swig_obj[0]) || PyList_Check(swig_obj[0])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[0]) ?
      PyTuple_Size(swig_obj[0]) :
        PyList_Size(swig_obj[0]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[0],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp1 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[0],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp1[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp1[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inverse" "', argument " "1"" of type '" "Matrix const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inverse" "', argument " "1"" of type '" "Matrix const &""'"); 
      }
      arg1 = reinterpret_cast< Matrix * >(argp1);
    }
  }
  {
    try {
      result = inverse((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_transpose(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyTuple_Check(swig_obj[0]) || PyList_Check(swig_obj[0])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[0]) ?
      PyTuple_Size(swig_obj[0]) :
        PyList_Size(swig_obj[0]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[0],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp1 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[0],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp1[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp1[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "transpose" "', argument " "1"" of type '" "Matrix const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "transpose" "', argument " "1"" of type '" "Matrix const &""'"); 
      }
      arg1 = reinterpret_cast< Matrix * >(argp1);
    }
  }
  {
    try {
      result = transpose((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_outerProduct(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "outerProduct", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outerProduct" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "outerProduct" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outerProduct" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "outerProduct" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = outerProduct((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pseudoSqrt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  SalvagingAlgorithm::Type arg2 ;
  Matrix temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "pseudoSqrt", 2, 2, swig_obj)) SWIG_fail;
  {
    if (PyTuple_Check(swig_obj[0]) || PyList_Check(swig_obj[0])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[0]) ?
      PyTuple_Size(swig_obj[0]) :
        PyList_Size(swig_obj[0]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[0],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp1 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[0],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp1[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp1[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pseudoSqrt" "', argument " "1"" of type '" "Matrix const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pseudoSqrt" "', argument " "1"" of type '" "Matrix const &""'"); 
      }
      arg1 = reinterpret_cast< Matrix * >(argp1);
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pseudoSqrt" "', argument " "2"" of type '" "SalvagingAlgorithm::Type""'");
  } 
  arg2 = static_cast< SalvagingAlgorithm::Type >(val2);
  {
    try {
      result = pseudoSqrt((Matrix const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SVD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  Matrix temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SVD *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    if (PyTuple_Check(swig_obj[0]) || PyList_Check(swig_obj[0])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[0]) ?
      PyTuple_Size(swig_obj[0]) :
        PyList_Size(swig_obj[0]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[0],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp1 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[0],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp1[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp1[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SVD" "', argument " "1"" of type '" "Matrix const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SVD" "', argument " "1"" of type '" "Matrix const &""'"); 
      }
      arg1 = reinterpret_cast< Matrix * >(argp1);
    }
  }
  {
    try {
      result = (SVD *)new SVD((Matrix const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SVD_U(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SVD *arg1 = (SVD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SVD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVD_U" "', argument " "1"" of type '" "SVD const *""'"); 
  }
  arg1 = reinterpret_cast< SVD * >(argp1);
  {
    try {
      result = (Matrix *) &((SVD const *)arg1)->U();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SVD_V(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SVD *arg1 = (SVD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SVD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVD_V" "', argument " "1"" of type '" "SVD const *""'"); 
  }
  arg1 = reinterpret_cast< SVD * >(argp1);
  {
    try {
      result = (Matrix *) &((SVD const *)arg1)->V();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SVD_S(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SVD *arg1 = (SVD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SVD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVD_S" "', argument " "1"" of type '" "SVD const *""'"); 
  }
  arg1 = reinterpret_cast< SVD * >(argp1);
  {
    try {
      result = ((SVD const *)arg1)->S();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SVD_singularValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SVD *arg1 = (SVD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SVD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVD_singularValues" "', argument " "1"" of type '" "SVD const *""'"); 
  }
  arg1 = reinterpret_cast< SVD * >(argp1);
  {
    try {
      result = (Array *) &((SVD const *)arg1)->singularValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SVD(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SVD *arg1 = (SVD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SVD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SVD" "', argument " "1"" of type '" "SVD *""'"); 
  }
  arg1 = reinterpret_cast< SVD * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SVD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SVD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SVD_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MatrixMultiplicationProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  MatrixMultiplicationProxy *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      result = (MatrixMultiplicationProxy *)new MatrixMultiplicationProxy(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MatrixMultiplicationProxy___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = (MatrixMultiplicationProxy *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "MatrixMultiplicationProxy___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MatrixMultiplicationProxy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixMultiplicationProxy___call__" "', argument " "1"" of type '" "MatrixMultiplicationProxy const *""'"); 
  }
  arg1 = reinterpret_cast< MatrixMultiplicationProxy * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixMultiplicationProxy___call__" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixMultiplicationProxy___call__" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = MatrixMultiplicationProxy_operator_Sp__SP_((MatrixMultiplicationProxy const *)arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MatrixMultiplicationProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = (MatrixMultiplicationProxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatrixMultiplicationProxy" "', argument " "1"" of type '" "MatrixMultiplicationProxy *""'"); 
  }
  arg1 = reinterpret_cast< MatrixMultiplicationProxy * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatrixMultiplicationProxy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MatrixMultiplicationProxy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BiCGstab_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BiCGstab *arg1 = (BiCGstab *) 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BiCGstab const > tempshared1 ;
  ext::shared_ptr< BiCGstab const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Array result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGstab_solve" "', argument " "1"" of type '" "BiCGstab const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BiCGstab > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BiCGstab > * >(argp1);
      arg1 = const_cast< BiCGstab * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BiCGstab > * >(argp1);
      arg1 = const_cast< BiCGstab * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGstab_solve" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGstab_solve" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGstab_solve" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGstab_solve" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = BiCGstab_solve__SWIG_0((BiCGstab const *)arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BiCGstab_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BiCGstab *arg1 = (BiCGstab *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BiCGstab const > tempshared1 ;
  ext::shared_ptr< BiCGstab const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGstab_solve" "', argument " "1"" of type '" "BiCGstab const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BiCGstab > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BiCGstab > * >(argp1);
      arg1 = const_cast< BiCGstab * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BiCGstab > * >(argp1);
      arg1 = const_cast< BiCGstab * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGstab_solve" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGstab_solve" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = BiCGstab_solve__SWIG_0((BiCGstab const *)arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BiCGstab_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGstab_solve", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_BiCGstab_solve__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_BiCGstab_solve__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGstab_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BiCGstab::solve(Array const &,Array const &) const\n"
    "    BiCGstab::solve(Array const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BiCGstab__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  BiCGstab *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MatrixMultiplicationProxy,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCGstab" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BiCGstab" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  arg1 = reinterpret_cast< MatrixMultiplicationProxy * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BiCGstab" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BiCGstab" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (BiCGstab *)new_BiCGstab__SWIG_0((MatrixMultiplicationProxy const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BiCGstab > *smartresult = result ? new ext::shared_ptr<  BiCGstab >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BiCGstab__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  MatrixMultiplicationProxy *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  BiCGstab *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MatrixMultiplicationProxy,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCGstab" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BiCGstab" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  arg1 = reinterpret_cast< MatrixMultiplicationProxy * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BiCGstab" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BiCGstab" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_MatrixMultiplicationProxy,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BiCGstab" "', argument " "4"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BiCGstab" "', argument " "4"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  arg4 = reinterpret_cast< MatrixMultiplicationProxy * >(argp4);
  {
    try {
      result = (BiCGstab *)new_BiCGstab__SWIG_1((MatrixMultiplicationProxy const &)*arg1,SWIG_STD_MOVE(arg2),arg3,(MatrixMultiplicationProxy const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BiCGstab > *smartresult = result ? new ext::shared_ptr<  BiCGstab >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BiCGstab(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BiCGstab", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BiCGstab__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BiCGstab__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BiCGstab'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BiCGstab::BiCGstab(MatrixMultiplicationProxy const &,Size,Real)\n"
    "    BiCGstab::BiCGstab(MatrixMultiplicationProxy const &,Size,Real,MatrixMultiplicationProxy const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BiCGstab(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BiCGstab *arg1 = (BiCGstab *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BiCGstab > tempshared1 ;
  ext::shared_ptr< BiCGstab > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGstab" "', argument " "1"" of type '" "BiCGstab *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BiCGstab > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BiCGstab > * >(argp1);
      arg1 = const_cast< BiCGstab * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BiCGstab > * >(argp1);
      arg1 = const_cast< BiCGstab * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BiCGstab_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BiCGstab_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BiCGstab_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_GMRES_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GMRES *arg1 = (GMRES *) 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GMRES const > tempshared1 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Array result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES_solve" "', argument " "1"" of type '" "GMRES const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES_solve" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES_solve" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES_solve" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES_solve" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = GMRES_solve__SWIG_0((GMRES const *)arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GMRES_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GMRES *arg1 = (GMRES *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GMRES const > tempshared1 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES_solve" "', argument " "1"" of type '" "GMRES const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES_solve" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES_solve" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = GMRES_solve__SWIG_0((GMRES const *)arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GMRES_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES_solve", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_GMRES_solve__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_GMRES_solve__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GMRES::solve(Array const &,Array const &) const\n"
    "    GMRES::solve(Array const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GMRES_solveWithRestart__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GMRES *arg1 = (GMRES *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Array *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GMRES const > tempshared1 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Array temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Array result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES_solveWithRestart" "', argument " "1"" of type '" "GMRES const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GMRES_solveWithRestart" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES_solveWithRestart" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES_solveWithRestart" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[3],&temp4)) {
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES_solveWithRestart" "', argument " "4"" of type '" "Array const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES_solveWithRestart" "', argument " "4"" of type '" "Array const &""'"); 
      }
      arg4 = reinterpret_cast< Array * >(argp4);
    }
  }
  {
    try {
      result = GMRES_solveWithRestart__SWIG_0((GMRES const *)arg1,SWIG_STD_MOVE(arg2),(Array const &)*arg3,(Array const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GMRES_solveWithRestart__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GMRES *arg1 = (GMRES *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GMRES const > tempshared1 ;
  ext::shared_ptr< GMRES const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Array result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES_solveWithRestart" "', argument " "1"" of type '" "GMRES const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GMRES_solveWithRestart" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES_solveWithRestart" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES_solveWithRestart" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = GMRES_solveWithRestart__SWIG_0((GMRES const *)arg1,SWIG_STD_MOVE(arg2),(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GMRES_solveWithRestart(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES_solveWithRestart", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_GMRES_solveWithRestart__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              Size size = PySequence_Size(argv[3]);
              if (size == 0) {
                _v = 1;
              } else {
                PyObject* o = PySequence_GetItem(argv[3],0);
                if (PyNumber_Check(o))
                _v = 1;
                else
                _v = 0;
                Py_DECREF(o);
              }
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            return _wrap_GMRES_solveWithRestart__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES_solveWithRestart'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GMRES::solveWithRestart(Size,Array const &,Array const &) const\n"
    "    GMRES::solveWithRestart(Size,Array const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_GMRES__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  GMRES *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MatrixMultiplicationProxy,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GMRES" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GMRES" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  arg1 = reinterpret_cast< MatrixMultiplicationProxy * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GMRES" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GMRES" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (GMRES *)new_GMRES__SWIG_0((MatrixMultiplicationProxy const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GMRES > *smartresult = result ? new ext::shared_ptr<  GMRES >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GMRES_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GMRES__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MatrixMultiplicationProxy *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  MatrixMultiplicationProxy *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  GMRES *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MatrixMultiplicationProxy,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GMRES" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GMRES" "', argument " "1"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  arg1 = reinterpret_cast< MatrixMultiplicationProxy * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GMRES" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GMRES" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_MatrixMultiplicationProxy,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GMRES" "', argument " "4"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GMRES" "', argument " "4"" of type '" "MatrixMultiplicationProxy const &""'"); 
  }
  arg4 = reinterpret_cast< MatrixMultiplicationProxy * >(argp4);
  {
    try {
      result = (GMRES *)new_GMRES__SWIG_1((MatrixMultiplicationProxy const &)*arg1,SWIG_STD_MOVE(arg2),arg3,(MatrixMultiplicationProxy const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GMRES > *smartresult = result ? new ext::shared_ptr<  GMRES >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GMRES_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GMRES(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GMRES", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_GMRES__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_MatrixMultiplicationProxy, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_GMRES__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GMRES'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GMRES::GMRES(MatrixMultiplicationProxy const &,Size,Real)\n"
    "    GMRES::GMRES(MatrixMultiplicationProxy const &,Size,Real,MatrixMultiplicationProxy const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GMRES(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GMRES *arg1 = (GMRES *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GMRES > tempshared1 ;
  ext::shared_ptr< GMRES > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GMRES_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRES" "', argument " "1"" of type '" "GMRES *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GMRES > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GMRES > * >(argp1);
      arg1 = const_cast< GMRES * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GMRES_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GMRES_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GMRES_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_close__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "close" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "close" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (bool)close(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_close__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "close" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "close" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "close" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (bool)close(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_close(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "close", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_close__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_close__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'close'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    close(Real,Real)\n"
    "    close(Real,Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_close_enough__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "close_enough" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "close_enough" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (bool)close_enough(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_close_enough__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "close_enough" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "close_enough" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "close_enough" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (bool)close_enough(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_close_enough(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "close_enough", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_close_enough__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_close_enough__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'close_enough'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    close_enough(Real,Real)\n"
    "    close_enough(Real,Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Quote_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Quote *arg1 = (Quote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Quote const > tempshared1 ;
  ext::shared_ptr< Quote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quote_value" "', argument " "1"" of type '" "Quote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Quote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Quote > * >(argp1);
      arg1 = const_cast< Quote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Quote > * >(argp1);
      arg1 = const_cast< Quote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Quote const *)arg1)->value();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Quote_isValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Quote *arg1 = (Quote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Quote const > tempshared1 ;
  ext::shared_ptr< Quote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quote_isValid" "', argument " "1"" of type '" "Quote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Quote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Quote > * >(argp1);
      arg1 = const_cast< Quote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Quote > * >(argp1);
      arg1 = const_cast< Quote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((Quote const *)arg1)->isValid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Quote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Quote *arg1 = (Quote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Quote > tempshared1 ;
  ext::shared_ptr< Quote > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quote" "', argument " "1"" of type '" "Quote *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Quote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Quote > * >(argp1);
      arg1 = const_cast< Quote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Quote > * >(argp1);
      arg1 = const_cast< Quote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Quote_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Quote > tempshared1 ;
  Handle< Quote > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteHandle" "', argument " "1"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< Quote > *)new Handle< Quote >((ext::shared_ptr< Quote > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< Quote > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< Quote > *)new Handle< Quote >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuoteHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_QuoteHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuoteHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< Quote >::Handle(ext::shared_ptr< Quote > const &)\n"
    "    Handle< Quote >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle___deref__" "', argument " "1"" of type '" "Handle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Quote > *smartresult = result ? new ext::shared_ptr<  Quote >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle_currentLink" "', argument " "1"" of type '" "Handle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Quote > *smartresult = result ? new ext::shared_ptr<  Quote >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle___nonzero__" "', argument " "1"" of type '" "Handle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_Quote_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle___bool__" "', argument " "1"" of type '" "Handle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_Quote_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle_asObservable" "', argument " "1"" of type '" "Handle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = Handle_Sl_Quote_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuoteHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteHandle" "', argument " "1"" of type '" "Handle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandle_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle_value" "', argument " "1"" of type '" "Handle< Quote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->value();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandle_isValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = (Handle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandle_isValid" "', argument " "1"" of type '" "Handle< Quote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->isValid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_Quote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuoteHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Quote > tempshared1 ;
  RelinkableHandle< Quote > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableQuoteHandle" "', argument " "1"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< Quote > *)new RelinkableHandle< Quote >((ext::shared_ptr< Quote > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< Quote > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< Quote > *)new RelinkableHandle< Quote >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableQuoteHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableQuoteHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableQuoteHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableQuoteHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< Quote >::RelinkableHandle(ext::shared_ptr< Quote > const &)\n"
    "    RelinkableHandle< Quote >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< Quote > *arg1 = (RelinkableHandle< Quote > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Quote > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< Quote > *arg1 = (RelinkableHandle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_Quote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< Quote > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_Quote_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableQuoteHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< Quote > *arg1 = (RelinkableHandle< Quote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableQuoteHandle" "', argument " "1"" of type '" "RelinkableHandle< Quote > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< Quote > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableQuoteHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableQuoteHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SimpleQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SimpleQuote *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SimpleQuote" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (SimpleQuote *)new SimpleQuote(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SimpleQuote > *smartresult = result ? new ext::shared_ptr<  SimpleQuote >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SimpleQuote_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpleQuote_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpleQuote *arg1 = (SimpleQuote *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SimpleQuote > tempshared1 ;
  ext::shared_ptr< SimpleQuote > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SimpleQuote_setValue", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SimpleQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleQuote_setValue" "', argument " "1"" of type '" "SimpleQuote *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SimpleQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SimpleQuote > * >(argp1);
      arg1 = const_cast< SimpleQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SimpleQuote > * >(argp1);
      arg1 = const_cast< SimpleQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleQuote_setValue" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setValue(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SimpleQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpleQuote *arg1 = (SimpleQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SimpleQuote > tempshared1 ;
  ext::shared_ptr< SimpleQuote > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SimpleQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleQuote" "', argument " "1"" of type '" "SimpleQuote *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SimpleQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SimpleQuote > * >(argp1);
      arg1 = const_cast< SimpleQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SimpleQuote > * >(argp1);
      arg1 = const_cast< SimpleQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SimpleQuote_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SimpleQuote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SimpleQuote_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LastFixingQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Index > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  LastFixingQuote *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastFixingQuote" "', argument " "1"" of type '" "ext::shared_ptr< Index >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastFixingQuote" "', argument " "1"" of type '" "ext::shared_ptr< Index >""'");
    } else {
      ext::shared_ptr< Index > * temp = reinterpret_cast< ext::shared_ptr< Index > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (LastFixingQuote *)new LastFixingQuote(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LastFixingQuote > *smartresult = result ? new ext::shared_ptr<  LastFixingQuote >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LastFixingQuote_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LastFixingQuote_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LastFixingQuote *arg1 = (LastFixingQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LastFixingQuote const > tempshared1 ;
  ext::shared_ptr< LastFixingQuote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Index > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LastFixingQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LastFixingQuote_index" "', argument " "1"" of type '" "LastFixingQuote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LastFixingQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LastFixingQuote > * >(argp1);
      arg1 = const_cast< LastFixingQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LastFixingQuote > * >(argp1);
      arg1 = const_cast< LastFixingQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((LastFixingQuote const *)arg1)->index();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ext::shared_ptr< Index >(result)), SWIGTYPE_p_ext__shared_ptrT_Index_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LastFixingQuote_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LastFixingQuote *arg1 = (LastFixingQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LastFixingQuote const > tempshared1 ;
  ext::shared_ptr< LastFixingQuote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LastFixingQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LastFixingQuote_referenceDate" "', argument " "1"" of type '" "LastFixingQuote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LastFixingQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LastFixingQuote > * >(argp1);
      arg1 = const_cast< LastFixingQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LastFixingQuote > * >(argp1);
      arg1 = const_cast< LastFixingQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((LastFixingQuote const *)arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LastFixingQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LastFixingQuote *arg1 = (LastFixingQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LastFixingQuote > tempshared1 ;
  ext::shared_ptr< LastFixingQuote > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LastFixingQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastFixingQuote" "', argument " "1"" of type '" "LastFixingQuote *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LastFixingQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LastFixingQuote > * >(argp1);
      arg1 = const_cast< LastFixingQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LastFixingQuote > * >(argp1);
      arg1 = const_cast< LastFixingQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastFixingQuote_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LastFixingQuote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LastFixingQuote_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DerivedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  DerivedQuote< UnaryFunction > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DerivedQuote", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivedQuote" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivedQuote" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (DerivedQuote< UnaryFunction > *)new_DerivedQuote_Sl_UnaryFunction_Sg_((Handle< Quote > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DerivedQuote<UnaryFunction> > *smartresult = result ? new ext::shared_ptr<  DerivedQuote<UnaryFunction> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DerivedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DerivedQuote< UnaryFunction > *arg1 = (DerivedQuote< UnaryFunction > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DerivedQuote< UnaryFunction > > tempshared1 ;
  ext::shared_ptr< DerivedQuote< UnaryFunction > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivedQuote" "', argument " "1"" of type '" "DerivedQuote< UnaryFunction > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DerivedQuote<UnaryFunction> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DerivedQuote<UnaryFunction> > * >(argp1);
      arg1 = const_cast< DerivedQuote< UnaryFunction > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DerivedQuote<UnaryFunction> > * >(argp1);
      arg1 = const_cast< DerivedQuote< UnaryFunction > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivedQuote_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DerivedQuote_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CompositeQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  CompositeQuote< BinaryFunction > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CompositeQuote", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeQuote" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeQuote" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompositeQuote" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeQuote" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = (CompositeQuote< BinaryFunction > *)new_CompositeQuote_Sl_BinaryFunction_Sg_((Handle< Quote > const &)*arg1,(Handle< Quote > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompositeQuote<BinaryFunction> > *smartresult = result ? new ext::shared_ptr<  CompositeQuote<BinaryFunction> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CompositeQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompositeQuote< BinaryFunction > *arg1 = (CompositeQuote< BinaryFunction > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeQuote< BinaryFunction > > tempshared1 ;
  ext::shared_ptr< CompositeQuote< BinaryFunction > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositeQuote" "', argument " "1"" of type '" "CompositeQuote< BinaryFunction > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeQuote<BinaryFunction> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeQuote<BinaryFunction> > * >(argp1);
      arg1 = const_cast< CompositeQuote< BinaryFunction > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeQuote<BinaryFunction> > * >(argp1);
      arg1 = const_cast< CompositeQuote< BinaryFunction > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompositeQuote_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompositeQuote_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_QuoteVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____bool__((std::vector< ext::shared_ptr< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____len__((std::vector< ext::shared_ptr< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_QuoteVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::__setslice__(std::vector< ext::shared_ptr< Quote > >::difference_type,std::vector< ext::shared_ptr< Quote > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Quote > >::__setslice__(std::vector< ext::shared_ptr< Quote > >::difference_type,std::vector< ext::shared_ptr< Quote > >::difference_type,std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::__delitem__(std::vector< ext::shared_ptr< Quote > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Quote > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Quote > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< Quote > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Quote > *smartresult = *result ? new ext::shared_ptr<  Quote >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Quote > >::__getitem__(std::vector< ext::shared_ptr< Quote > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Quote > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)\n"
    "    std::vector< ext::shared_ptr< Quote > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Quote > >::__setitem__(std::vector< ext::shared_ptr< Quote > >::difference_type,std::vector< ext::shared_ptr< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Quote > *smartresult = result ? new ext::shared_ptr<  Quote >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__append(arg1,(ext::shared_ptr< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > > *)new std::vector< ext::shared_ptr< Quote > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > > *)new std::vector< ext::shared_ptr< Quote > >((std::vector< ext::shared_ptr< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< Quote > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Quote > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< Quote > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Quote > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< Quote > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Quote_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > > *)new std::vector< ext::shared_ptr< Quote > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< Quote > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Quote > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< Quote > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_QuoteVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_QuoteVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::erase(std::vector< ext::shared_ptr< Quote > >::iterator)\n"
    "    std::vector< ext::shared_ptr< Quote > >::erase(std::vector< ext::shared_ptr< Quote > >::iterator,std::vector< ext::shared_ptr< Quote > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_QuoteVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > >::size_type arg1 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuoteVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > > *)new std::vector< ext::shared_ptr< Quote > >(arg1,(std::vector< ext::shared_ptr< Quote > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuoteVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_QuoteVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_QuoteVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_QuoteVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuoteVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::vector()\n"
    "    std::vector< ext::shared_ptr< Quote > >::vector(std::vector< ext::shared_ptr< Quote > > const &)\n"
    "    std::vector< ext::shared_ptr< Quote > >::vector(std::vector< ext::shared_ptr< Quote > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Quote > >::vector(std::vector< ext::shared_ptr< Quote > >::size_type,std::vector< ext::shared_ptr< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< Quote > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > >::value_type *) &((std::vector< ext::shared_ptr< Quote > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Quote > *smartresult = *result ? new ext::shared_ptr<  Quote >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Quote > >::value_type *) &((std::vector< ext::shared_ptr< Quote > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Quote > *smartresult = *result ? new ext::shared_ptr<  Quote >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< Quote > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< Quote > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::resize(std::vector< ext::shared_ptr< Quote > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Quote > >::resize(std::vector< ext::shared_ptr< Quote > >::size_type,std::vector< ext::shared_ptr< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< Quote > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Quote > >::size_type arg3 ;
  std::vector< ext::shared_ptr< Quote > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< Quote > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Quote > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< Quote > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Quote > >::insert(std::vector< ext::shared_ptr< Quote > >::iterator,std::vector< ext::shared_ptr< Quote > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< Quote > >::insert(std::vector< ext::shared_ptr< Quote > >::iterator,std::vector< ext::shared_ptr< Quote > >::size_type,std::vector< ext::shared_ptr< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  std::vector< ext::shared_ptr< Quote > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Quote > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Quote > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuoteVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Quote > > *arg1 = (std::vector< ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuoteVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_QuoteVectorVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____nonzero__((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____bool__((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____len__((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVectorVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *)std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg3 ;
  std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_QuoteVectorVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteVectorVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__setslice__(std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__setslice__(std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type,std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type,std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVectorVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *)std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteVectorVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteVectorVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__delitem__(std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *) &std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteVectorVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteVectorVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__getitem__(std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type >(val2);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteVectorVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVectorVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVectorVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > const &)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::__setitem__(std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_append" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__append(arg1,(std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVectorVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new std::vector< std::vector< ext::shared_ptr< Quote > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVectorVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new std::vector< std::vector< ext::shared_ptr< Quote > > >((std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_size" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_end" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< ext::shared_ptr< Quote > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVectorVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new std::vector< std::vector< ext::shared_ptr< Quote > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_QuoteVectorVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_QuoteVectorVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::erase(std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::erase(std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator,std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_QuoteVectorVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg1 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val1);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuoteVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > > *)new std::vector< std::vector< ext::shared_ptr< Quote > > >(arg1,(std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteVectorVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuoteVectorVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_QuoteVectorVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_QuoteVectorVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteVectorVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_QuoteVectorVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuoteVectorVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::vector()\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::vector(std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > const &)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::vector(std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::vector(std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_front" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *) &((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_back" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *) &((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteVectorVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVectorVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::resize(std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::resize(std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator arg2 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg3 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val3);
  {
    std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *ptr = (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteVectorVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteVectorVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >,std::allocator< std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Quote >,std::allocator< ext::shared_ptr< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteVectorVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteVectorVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::insert(std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)\n"
    "    std::vector< std::vector< ext::shared_ptr< Quote > > >::insert(std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator,std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type,std::vector< std::vector< ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteVectorVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteVectorVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteVectorVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteVectorVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< ext::shared_ptr< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuoteVectorVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::vector< ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteVectorVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_Quote_t_std__allocatorT_ext__shared_ptrT_Quote_t_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuoteVectorVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_QuoteHandleVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_iterator" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_Handle_Sl_Quote_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___nonzero__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Handle_Sl_Quote_Sg__Sg____nonzero__((std::vector< Handle< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___bool__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Handle_Sl_Quote_Sg__Sg____bool__((std::vector< Handle< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___len__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = std_vector_Sl_Handle_Sl_Quote_Sg__Sg____len__((std::vector< Handle< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  std::vector< Handle< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___getslice__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___getslice__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVector___getslice__" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Handle< Quote > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)std_vector_Sl_Handle_Sl_Quote_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  std::vector< Handle< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___setslice__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___setslice__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVector___setslice__" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Handle< Quote > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  std::vector< Handle< Quote > >::difference_type arg3 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___setslice__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___setslice__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVector___setslice__" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Handle< Quote > >::difference_type >(val3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteHandleVector___setslice__" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector___setslice__" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_QuoteHandleVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteHandleVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::__setslice__(std::vector< Handle< Quote > >::difference_type,std::vector< Handle< Quote > >::difference_type)\n"
    "    std::vector< Handle< Quote > >::__setslice__(std::vector< Handle< Quote > >::difference_type,std::vector< Handle< Quote > >::difference_type,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  std::vector< Handle< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___delslice__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___delslice__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVector___delslice__" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Handle< Quote > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___delitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___delitem__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___getitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)std_vector_Sl_Handle_Sl_Quote_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___setitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___setitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___delitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteHandleVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteHandleVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::__delitem__(std::vector< Handle< Quote > >::difference_type)\n"
    "    std::vector< Handle< Quote > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< Handle< Quote > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___getitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___getitem__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< Handle< Quote > >::value_type *) &std_vector_Sl_Handle_Sl_Quote_Sg__Sg____getitem____SWIG_1((std::vector< Handle< Quote > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Handle< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteHandleVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteHandleVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Handle< Quote > >::__getitem__(std::vector< Handle< Quote > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::difference_type arg2 ;
  std::vector< Handle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector___setitem__" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector___setitem__" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_Handle_Sl_Quote_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(Handle< Quote > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteHandleVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    std::vector< Handle< Quote > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Handle< Quote > >::__setitem__(std::vector< Handle< Quote > >::difference_type,std::vector< Handle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_pop" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_Handle_Sl_Quote_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Handle< Quote > >::value_type(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_append" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteHandleVector_append" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_append" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_Handle_Sl_Quote_Sg__Sg__append(arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< Handle< Quote > > *)new std::vector< Handle< Quote > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteHandleVector" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteHandleVector" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< Handle< Quote > > *)new std::vector< Handle< Quote > >((std::vector< Handle< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_empty" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< Handle< Quote > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_size" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< Handle< Quote > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_swap" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteHandleVector_swap" "', argument " "2"" of type '" "std::vector< Handle< Quote > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_swap" "', argument " "2"" of type '" "std::vector< Handle< Quote > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_begin" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_end" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_rbegin" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_rend" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_clear" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< Handle< Quote > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_get_allocator" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< Handle< Quote > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< Handle< Quote > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_HandleT_Quote_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteHandleVector" "', argument " "1"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Handle< Quote > >::size_type >(val1);
  {
    try {
      result = (std::vector< Handle< Quote > > *)new std::vector< Handle< Quote > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_pop_back" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_resize" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector_resize" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< Handle< Quote > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_erase" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Handle_Sl_Quote_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::iterator arg2 ;
  std::vector< Handle< Quote > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< Handle< Quote > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_erase" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_erase" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_erase" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Handle_Sl_Quote_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_QuoteHandleVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_QuoteHandleVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::erase(std::vector< Handle< Quote > >::iterator)\n"
    "    std::vector< Handle< Quote > >::erase(std::vector< Handle< Quote > >::iterator,std::vector< Handle< Quote > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > >::size_type arg1 ;
  std::vector< Handle< Quote > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< Handle< Quote > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteHandleVector" "', argument " "1"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Handle< Quote > >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuoteHandleVector" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteHandleVector" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp2);
  {
    try {
      result = (std::vector< Handle< Quote > > *)new std::vector< Handle< Quote > >(arg1,(std::vector< Handle< Quote > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuoteHandleVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_QuoteHandleVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_QuoteHandleVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteHandleVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_QuoteHandleVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuoteHandleVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::vector()\n"
    "    std::vector< Handle< Quote > >::vector(std::vector< Handle< Quote > > const &)\n"
    "    std::vector< Handle< Quote > >::vector(std::vector< Handle< Quote > >::size_type)\n"
    "    std::vector< Handle< Quote > >::vector(std::vector< Handle< Quote > >::size_type,std::vector< Handle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_push_back" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteHandleVector_push_back" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_push_back" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< Handle< Quote > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_front" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (std::vector< Handle< Quote > >::value_type *) &((std::vector< Handle< Quote > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Handle< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_back" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = (std::vector< Handle< Quote > >::value_type *) &((std::vector< Handle< Quote > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< Handle< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type arg2 ;
  std::vector< Handle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_assign" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector_assign" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVector_assign" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_assign" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< Handle< Quote > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type arg2 ;
  std::vector< Handle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_resize" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector_resize" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVector_resize" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_resize" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< Handle< Quote > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteHandleVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::resize(std::vector< Handle< Quote > >::size_type)\n"
    "    std::vector< Handle< Quote > >::resize(std::vector< Handle< Quote > >::size_type,std::vector< Handle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::iterator arg2 ;
  std::vector< Handle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< Handle< Quote > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_insert" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVector_insert" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_insert" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_Handle_Sl_Quote_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Handle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::iterator arg2 ;
  std::vector< Handle< Quote > >::size_type arg3 ;
  std::vector< Handle< Quote > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_insert" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVector_insert" "', argument " "3"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Handle< Quote > >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteHandleVector_insert" "', argument " "4"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVector_insert" "', argument " "4"" of type '" "std::vector< Handle< Quote > >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Handle< Quote > >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_Handle_Sl_Quote_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Handle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteHandleVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Handle< Quote > >::insert(std::vector< Handle< Quote > >::iterator,std::vector< Handle< Quote > >::value_type const &)\n"
    "    std::vector< Handle< Quote > >::insert(std::vector< Handle< Quote > >::iterator,std::vector< Handle< Quote > >::size_type,std::vector< Handle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  std::vector< Handle< Quote > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_reserve" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVector_reserve" "', argument " "2"" of type '" "std::vector< Handle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Handle< Quote > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Handle< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVector_capacity" "', argument " "1"" of type '" "std::vector< Handle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< Handle< Quote > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuoteHandleVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Handle< Quote > > *arg1 = (std::vector< Handle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteHandleVector" "', argument " "1"" of type '" "std::vector< Handle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Handle< Quote > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteHandleVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuoteHandleVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____nonzero__((std::vector< std::vector< Handle< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____bool__((std::vector< std::vector< Handle< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____len__((std::vector< std::vector< Handle< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVectorVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg3 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val3);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_QuoteHandleVectorVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteHandleVectorVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::__setslice__(std::vector< std::vector< Handle< Quote > > >::difference_type,std::vector< std::vector< Handle< Quote > > >::difference_type)\n"
    "    std::vector< std::vector< Handle< Quote > > >::__setslice__(std::vector< std::vector< Handle< Quote > > >::difference_type,std::vector< std::vector< Handle< Quote > > >::difference_type,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVectorVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteHandleVectorVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteHandleVectorVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::__delitem__(std::vector< std::vector< Handle< Quote > > >::difference_type)\n"
    "    std::vector< std::vector< Handle< Quote > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< Handle< Quote > > >::value_type *) &std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1((std::vector< std::vector< Handle< Quote > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< Handle< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteHandleVectorVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteHandleVectorVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< Handle< Quote > > >::__getitem__(std::vector< std::vector< Handle< Quote > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::difference_type >(val2);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_QuoteHandleVectorVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVectorVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVectorVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)\n"
    "    std::vector< std::vector< Handle< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< Handle< Quote > > >::__setitem__(std::vector< std::vector< Handle< Quote > > >::difference_type,std::vector< std::vector< Handle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_append" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteHandleVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__append(arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVectorVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > > *)new std::vector< std::vector< Handle< Quote > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVectorVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > > *)new std::vector< std::vector< Handle< Quote > > >((std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< Handle< Quote > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_size" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< Handle< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteHandleVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_end" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< Handle< Quote > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< Handle< Quote > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVectorVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > > *)new std::vector< std::vector< Handle< Quote > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< Handle< Quote > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::iterator arg2 ;
  std::vector< std::vector< Handle< Quote > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< Handle< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_QuoteHandleVectorVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_QuoteHandleVectorVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::erase(std::vector< std::vector< Handle< Quote > > >::iterator)\n"
    "    std::vector< std::vector< Handle< Quote > > >::erase(std::vector< std::vector< Handle< Quote > > >::iterator,std::vector< std::vector< Handle< Quote > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVectorVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > >::size_type arg1 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< Handle< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuoteHandleVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteHandleVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > > *)new std::vector< std::vector< Handle< Quote > > >(arg1,(std::vector< std::vector< Handle< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteHandleVectorVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuoteHandleVectorVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_QuoteHandleVectorVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_QuoteHandleVectorVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteHandleVectorVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_QuoteHandleVectorVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuoteHandleVectorVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::vector()\n"
    "    std::vector< std::vector< Handle< Quote > > >::vector(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > const &)\n"
    "    std::vector< std::vector< Handle< Quote > > >::vector(std::vector< std::vector< Handle< Quote > > >::size_type)\n"
    "    std::vector< std::vector< Handle< Quote > > >::vector(std::vector< std::vector< Handle< Quote > > >::size_type,std::vector< std::vector< Handle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuoteHandleVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< Handle< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_front" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > >::value_type *) &((std::vector< std::vector< Handle< Quote > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< Handle< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_back" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< Handle< Quote > > >::value_type *) &((std::vector< std::vector< Handle< Quote > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< Handle< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val2);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::vector< Handle< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type arg2 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val2);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::vector< Handle< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_QuoteHandleVectorVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVectorVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::resize(std::vector< std::vector< Handle< Quote > > >::size_type)\n"
    "    std::vector< std::vector< Handle< Quote > > >::resize(std::vector< std::vector< Handle< Quote > > >::size_type,std::vector< std::vector< Handle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::iterator arg2 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< Handle< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
    }
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuoteHandleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< Handle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::iterator arg2 ;
  std::vector< std::vector< Handle< Quote > > >::size_type arg3 ;
  std::vector< std::vector< Handle< Quote > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "QuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuoteHandleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuoteHandleVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuoteHandleVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< Handle< Quote > > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_Handle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_QuoteHandleVectorVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< Handle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_QuoteHandleVectorVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuoteHandleVectorVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< Handle< Quote > > >::insert(std::vector< std::vector< Handle< Quote > > >::iterator,std::vector< std::vector< Handle< Quote > > >::value_type const &)\n"
    "    std::vector< std::vector< Handle< Quote > > >::insert(std::vector< std::vector< Handle< Quote > > >::iterator,std::vector< std::vector< Handle< Quote > > >::size_type,std::vector< std::vector< Handle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  std::vector< std::vector< Handle< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "QuoteHandleVectorVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuoteHandleVectorVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< Handle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< Handle< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuoteHandleVectorVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< Handle< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuoteHandleVectorVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< Handle< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuoteHandleVectorVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< Handle< Quote > > > *arg1 = (std::vector< std::vector< Handle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< Handle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< Handle< Quote > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteHandleVectorVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_std__allocatorT_std__vectorT_HandleT_Quote_t_std__allocatorT_HandleT_Quote_t_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuoteHandleVectorVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_iterator" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___nonzero__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____nonzero__((std::vector< RelinkableHandle< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___bool__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____bool__((std::vector< RelinkableHandle< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___len__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____len__((std::vector< RelinkableHandle< Quote > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___getslice__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___getslice__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVector___getslice__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg3 ;
  std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val3);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "4"" of type '" "std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector___setslice__" "', argument " "4"" of type '" "std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RelinkableQuoteHandleVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RelinkableQuoteHandleVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::__setslice__(std::vector< RelinkableHandle< Quote > >::difference_type,std::vector< RelinkableHandle< Quote > >::difference_type)\n"
    "    std::vector< RelinkableHandle< Quote > >::__setslice__(std::vector< RelinkableHandle< Quote > >::difference_type,std::vector< RelinkableHandle< Quote > >::difference_type,std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___delslice__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___delslice__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVector___delslice__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___delitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___delitem__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___getitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___delitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::__delitem__(std::vector< RelinkableHandle< Quote > >::difference_type)\n"
    "    std::vector< RelinkableHandle< Quote > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< RelinkableHandle< Quote > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___getitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___getitem__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< RelinkableHandle< Quote > >::value_type *) &std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____getitem____SWIG_1((std::vector< RelinkableHandle< Quote > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_Quote_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< RelinkableHandle< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< RelinkableHandle< Quote > >::__getitem__(std::vector< RelinkableHandle< Quote > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::difference_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector___setitem__" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(RelinkableHandle< Quote > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)\n"
    "    std::vector< RelinkableHandle< Quote > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< RelinkableHandle< Quote > >::__setitem__(std::vector< RelinkableHandle< Quote > >::difference_type,std::vector< RelinkableHandle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_pop" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< RelinkableHandle< Quote > >::value_type(result)), SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_append" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandleVector_append" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_append" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__append(arg1,(RelinkableHandle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > > *)new std::vector< RelinkableHandle< Quote > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableQuoteHandleVector" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelinkableQuoteHandleVector" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > > *)new std::vector< RelinkableHandle< Quote > >((std::vector< RelinkableHandle< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_empty" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< RelinkableHandle< Quote > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_size" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< RelinkableHandle< Quote > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_swap" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandleVector_swap" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_swap" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_begin" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_end" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_rbegin" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_rend" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_clear" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< RelinkableHandle< Quote > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_get_allocator" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< RelinkableHandle< Quote > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< RelinkableHandle< Quote > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_RelinkableHandleT_Quote_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RelinkableQuoteHandleVector" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val1);
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > > *)new std::vector< RelinkableHandle< Quote > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_pop_back" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_resize" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector_resize" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< RelinkableHandle< Quote > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::iterator arg2 ;
  std::vector< RelinkableHandle< Quote > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< RelinkableHandle< Quote > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_erase" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_RelinkableQuoteHandleVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::erase(std::vector< RelinkableHandle< Quote > >::iterator)\n"
    "    std::vector< RelinkableHandle< Quote > >::erase(std::vector< RelinkableHandle< Quote > >::iterator,std::vector< RelinkableHandle< Quote > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > >::size_type arg1 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< RelinkableHandle< Quote > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RelinkableQuoteHandleVector" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RelinkableQuoteHandleVector" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelinkableQuoteHandleVector" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp2);
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > > *)new std::vector< RelinkableHandle< Quote > >(arg1,(std::vector< RelinkableHandle< Quote > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableQuoteHandleVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableQuoteHandleVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RelinkableQuoteHandleVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableQuoteHandleVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RelinkableQuoteHandleVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableQuoteHandleVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::vector()\n"
    "    std::vector< RelinkableHandle< Quote > >::vector(std::vector< RelinkableHandle< Quote > > const &)\n"
    "    std::vector< RelinkableHandle< Quote > >::vector(std::vector< RelinkableHandle< Quote > >::size_type)\n"
    "    std::vector< RelinkableHandle< Quote > >::vector(std::vector< RelinkableHandle< Quote > >::size_type,std::vector< RelinkableHandle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_push_back" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandleVector_push_back" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_push_back" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< RelinkableHandle< Quote > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_front" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > >::value_type *) &((std::vector< RelinkableHandle< Quote > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_Quote_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< RelinkableHandle< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_back" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = (std::vector< RelinkableHandle< Quote > >::value_type *) &((std::vector< RelinkableHandle< Quote > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_Quote_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< RelinkableHandle< Quote > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_assign" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector_assign" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVector_assign" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_assign" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< RelinkableHandle< Quote > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type arg2 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_resize" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector_resize" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVector_resize" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_resize" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< RelinkableHandle< Quote > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::resize(std::vector< RelinkableHandle< Quote > >::size_type)\n"
    "    std::vector< RelinkableHandle< Quote > >::resize(std::vector< RelinkableHandle< Quote > >::size_type,std::vector< RelinkableHandle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::iterator arg2 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< RelinkableHandle< Quote > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(RelinkableHandle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< RelinkableHandle< Quote > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::iterator arg2 ;
  std::vector< RelinkableHandle< Quote > >::size_type arg3 ;
  std::vector< RelinkableHandle< Quote > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "3"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_RelinkableHandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "4"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVector_insert" "', argument " "4"" of type '" "std::vector< RelinkableHandle< Quote > >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< RelinkableHandle< Quote > >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(RelinkableHandle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< RelinkableHandle< Quote > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_RelinkableHandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RelinkableQuoteHandleVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< RelinkableHandle< Quote > >::insert(std::vector< RelinkableHandle< Quote > >::iterator,std::vector< RelinkableHandle< Quote > >::value_type const &)\n"
    "    std::vector< RelinkableHandle< Quote > >::insert(std::vector< RelinkableHandle< Quote > >::iterator,std::vector< RelinkableHandle< Quote > >::size_type,std::vector< RelinkableHandle< Quote > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  std::vector< RelinkableHandle< Quote > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_reserve" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVector_reserve" "', argument " "2"" of type '" "std::vector< RelinkableHandle< Quote > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< RelinkableHandle< Quote > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< RelinkableHandle< Quote > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVector_capacity" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      result = ((std::vector< RelinkableHandle< Quote > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableQuoteHandleVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< RelinkableHandle< Quote > > *arg1 = (std::vector< RelinkableHandle< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableQuoteHandleVector" "', argument " "1"" of type '" "std::vector< RelinkableHandle< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< RelinkableHandle< Quote > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableQuoteHandleVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableQuoteHandleVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____nonzero__((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____bool__((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____len__((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVectorVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg3 ;
  std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val3);
  {
    std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *ptr = (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RelinkableQuoteHandleVectorVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RelinkableQuoteHandleVectorVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__setslice__(std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__setslice__(std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type,std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type,std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVectorVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *)std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *ptr = (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__delitem__(std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *) &std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< RelinkableHandle< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__getitem__(std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type >(val2);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVectorVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVectorVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > const &)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::__setitem__(std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_append" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandleVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_append" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__append(arg1,(std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVectorVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new std::vector< std::vector< RelinkableHandle< Quote > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVectorVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *ptr = (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableQuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelinkableQuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new std::vector< std::vector< RelinkableHandle< Quote > > >((std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_size" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandleVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_end" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< RelinkableHandle< Quote > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVectorVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RelinkableQuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new std::vector< std::vector< RelinkableHandle< Quote > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_RelinkableQuoteHandleVectorVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::erase(std::vector< std::vector< RelinkableHandle< Quote > > >::iterator)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::erase(std::vector< std::vector< RelinkableHandle< Quote > > >::iterator,std::vector< std::vector< RelinkableHandle< Quote > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVectorVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg1 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< RelinkableHandle< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RelinkableQuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val1);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RelinkableQuoteHandleVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelinkableQuoteHandleVectorVector" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > > *)new std::vector< std::vector< RelinkableHandle< Quote > > >(arg1,(std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableQuoteHandleVectorVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableQuoteHandleVectorVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableQuoteHandleVectorVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RelinkableQuoteHandleVectorVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableQuoteHandleVectorVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RelinkableQuoteHandleVectorVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableQuoteHandleVectorVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::vector()\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::vector(std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > const &)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::vector(std::vector< std::vector< RelinkableHandle< Quote > > >::size_type)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::vector(std::vector< std::vector< RelinkableHandle< Quote > > >::size_type,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableQuoteHandleVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_front" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *) &((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< RelinkableHandle< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_back" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *) &((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< RelinkableHandle< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val2);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val2);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RelinkableQuoteHandleVectorVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVectorVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::resize(std::vector< std::vector< RelinkableHandle< Quote > > >::size_type)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::resize(std::vector< std::vector< RelinkableHandle< Quote > > >::size_type,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
    }
  }
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< RelinkableHandle< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::iterator arg2 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg3 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val3);
  {
    std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *ptr = (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RelinkableQuoteHandleVectorVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_RelinkableHandle_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RelinkableQuoteHandleVectorVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >,std::allocator< std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< RelinkableHandle< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< RelinkableHandle< Quote >,std::allocator< RelinkableHandle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RelinkableQuoteHandleVectorVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RelinkableQuoteHandleVectorVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::insert(std::vector< std::vector< RelinkableHandle< Quote > > >::iterator,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)\n"
    "    std::vector< std::vector< RelinkableHandle< Quote > > >::insert(std::vector< std::vector< RelinkableHandle< Quote > > >::iterator,std::vector< std::vector< RelinkableHandle< Quote > > >::size_type,std::vector< std::vector< RelinkableHandle< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableQuoteHandleVectorVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RelinkableQuoteHandleVectorVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< RelinkableHandle< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableQuoteHandleVectorVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< RelinkableHandle< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableQuoteHandleVectorVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< RelinkableHandle< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableQuoteHandleVectorVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< RelinkableHandle< Quote > > > *arg1 = (std::vector< std::vector< RelinkableHandle< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableQuoteHandleVectorVector" "', argument " "1"" of type '" "std::vector< std::vector< RelinkableHandle< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< RelinkableHandle< Quote > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableQuoteHandleVectorVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_std__allocatorT_std__vectorT_RelinkableHandleT_Quote_t_std__allocatorT_RelinkableHandleT_Quote_t_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableQuoteHandleVectorVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Brent_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Brent *arg1 = (Brent *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Brent_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Brent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brent_setMaxEvaluations" "', argument " "1"" of type '" "Brent *""'"); 
  }
  arg1 = reinterpret_cast< Brent * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brent_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Brent_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Brent *arg1 = (Brent *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Brent_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Brent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brent_setLowerBound" "', argument " "1"" of type '" "Brent *""'"); 
  }
  arg1 = reinterpret_cast< Brent * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brent_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Brent_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Brent *arg1 = (Brent *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Brent_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Brent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brent_setUpperBound" "', argument " "1"" of type '" "Brent *""'"); 
  }
  arg1 = reinterpret_cast< Brent * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Brent_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Brent_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Brent *arg1 = (Brent *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Brent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brent_solve" "', argument " "1"" of type '" "Brent *""'"); 
  }
  arg1 = reinterpret_cast< Brent * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Brent_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Brent_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Brent_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)Brent_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Brent_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Brent *arg1 = (Brent *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Brent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Brent_solve" "', argument " "1"" of type '" "Brent *""'"); 
  }
  arg1 = reinterpret_cast< Brent * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Brent_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Brent_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Brent_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Brent_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)Brent_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Brent_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Brent_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Brent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Brent_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Brent, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Brent_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Brent_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Brent::solve(PyObject *,Real,Real,Real)\n"
    "    Brent::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Brent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Brent *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Brent", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Brent *)new Brent();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Brent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Brent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Brent *arg1 = (Brent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Brent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Brent" "', argument " "1"" of type '" "Brent *""'"); 
  }
  arg1 = reinterpret_cast< Brent * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Brent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Brent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Brent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Bisection_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bisection *arg1 = (Bisection *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Bisection_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bisection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bisection_setMaxEvaluations" "', argument " "1"" of type '" "Bisection *""'"); 
  }
  arg1 = reinterpret_cast< Bisection * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bisection_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bisection_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bisection *arg1 = (Bisection *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Bisection_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bisection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bisection_setLowerBound" "', argument " "1"" of type '" "Bisection *""'"); 
  }
  arg1 = reinterpret_cast< Bisection * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bisection_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bisection_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bisection *arg1 = (Bisection *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Bisection_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bisection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bisection_setUpperBound" "', argument " "1"" of type '" "Bisection *""'"); 
  }
  arg1 = reinterpret_cast< Bisection * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bisection_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bisection_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bisection *arg1 = (Bisection *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bisection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bisection_solve" "', argument " "1"" of type '" "Bisection *""'"); 
  }
  arg1 = reinterpret_cast< Bisection * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bisection_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bisection_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bisection_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)Bisection_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bisection_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bisection *arg1 = (Bisection *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bisection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bisection_solve" "', argument " "1"" of type '" "Bisection *""'"); 
  }
  arg1 = reinterpret_cast< Bisection * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bisection_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bisection_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bisection_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Bisection_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)Bisection_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bisection_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bisection_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Bisection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Bisection_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Bisection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Bisection_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bisection_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bisection::solve(PyObject *,Real,Real,Real)\n"
    "    Bisection::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Bisection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bisection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Bisection", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Bisection *)new Bisection();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Bisection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Bisection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bisection *arg1 = (Bisection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bisection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bisection" "', argument " "1"" of type '" "Bisection *""'"); 
  }
  arg1 = reinterpret_cast< Bisection * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bisection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Bisection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bisection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FalsePosition_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FalsePosition_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FalsePosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalsePosition_setMaxEvaluations" "', argument " "1"" of type '" "FalsePosition *""'"); 
  }
  arg1 = reinterpret_cast< FalsePosition * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FalsePosition_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FalsePosition_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FalsePosition_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FalsePosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalsePosition_setLowerBound" "', argument " "1"" of type '" "FalsePosition *""'"); 
  }
  arg1 = reinterpret_cast< FalsePosition * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FalsePosition_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FalsePosition_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FalsePosition_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FalsePosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalsePosition_setUpperBound" "', argument " "1"" of type '" "FalsePosition *""'"); 
  }
  arg1 = reinterpret_cast< FalsePosition * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FalsePosition_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FalsePosition_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FalsePosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalsePosition_solve" "', argument " "1"" of type '" "FalsePosition *""'"); 
  }
  arg1 = reinterpret_cast< FalsePosition * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FalsePosition_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FalsePosition_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FalsePosition_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)FalsePosition_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FalsePosition_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FalsePosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalsePosition_solve" "', argument " "1"" of type '" "FalsePosition *""'"); 
  }
  arg1 = reinterpret_cast< FalsePosition * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FalsePosition_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FalsePosition_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FalsePosition_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FalsePosition_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)FalsePosition_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FalsePosition_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FalsePosition_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FalsePosition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_FalsePosition_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FalsePosition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_FalsePosition_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FalsePosition_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FalsePosition::solve(PyObject *,Real,Real,Real)\n"
    "    FalsePosition::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_FalsePosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FalsePosition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FalsePosition", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (FalsePosition *)new FalsePosition();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FalsePosition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FalsePosition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FalsePosition *arg1 = (FalsePosition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FalsePosition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FalsePosition" "', argument " "1"" of type '" "FalsePosition *""'"); 
  }
  arg1 = reinterpret_cast< FalsePosition * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FalsePosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FalsePosition, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FalsePosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Ridder_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Ridder *arg1 = (Ridder *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Ridder_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Ridder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ridder_setMaxEvaluations" "', argument " "1"" of type '" "Ridder *""'"); 
  }
  arg1 = reinterpret_cast< Ridder * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ridder_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ridder_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Ridder *arg1 = (Ridder *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Ridder_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Ridder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ridder_setLowerBound" "', argument " "1"" of type '" "Ridder *""'"); 
  }
  arg1 = reinterpret_cast< Ridder * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ridder_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ridder_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Ridder *arg1 = (Ridder *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Ridder_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Ridder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ridder_setUpperBound" "', argument " "1"" of type '" "Ridder *""'"); 
  }
  arg1 = reinterpret_cast< Ridder * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ridder_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ridder_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Ridder *arg1 = (Ridder *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Ridder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ridder_solve" "', argument " "1"" of type '" "Ridder *""'"); 
  }
  arg1 = reinterpret_cast< Ridder * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ridder_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ridder_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Ridder_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)Ridder_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ridder_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Ridder *arg1 = (Ridder *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Ridder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ridder_solve" "', argument " "1"" of type '" "Ridder *""'"); 
  }
  arg1 = reinterpret_cast< Ridder * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ridder_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ridder_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Ridder_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Ridder_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)Ridder_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ridder_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Ridder_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ridder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Ridder_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ridder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Ridder_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Ridder_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Ridder::solve(PyObject *,Real,Real,Real)\n"
    "    Ridder::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Ridder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Ridder *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Ridder", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Ridder *)new Ridder();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ridder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Ridder(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Ridder *arg1 = (Ridder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Ridder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ridder" "', argument " "1"" of type '" "Ridder *""'"); 
  }
  arg1 = reinterpret_cast< Ridder * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Ridder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Ridder, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Ridder_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Secant_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Secant *arg1 = (Secant *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Secant_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Secant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Secant_setMaxEvaluations" "', argument " "1"" of type '" "Secant *""'"); 
  }
  arg1 = reinterpret_cast< Secant * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Secant_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Secant_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Secant *arg1 = (Secant *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Secant_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Secant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Secant_setLowerBound" "', argument " "1"" of type '" "Secant *""'"); 
  }
  arg1 = reinterpret_cast< Secant * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Secant_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Secant_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Secant *arg1 = (Secant *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Secant_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Secant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Secant_setUpperBound" "', argument " "1"" of type '" "Secant *""'"); 
  }
  arg1 = reinterpret_cast< Secant * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Secant_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Secant_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Secant *arg1 = (Secant *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Secant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Secant_solve" "', argument " "1"" of type '" "Secant *""'"); 
  }
  arg1 = reinterpret_cast< Secant * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Secant_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Secant_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Secant_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)Secant_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Secant_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Secant *arg1 = (Secant *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Secant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Secant_solve" "', argument " "1"" of type '" "Secant *""'"); 
  }
  arg1 = reinterpret_cast< Secant * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Secant_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Secant_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Secant_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Secant_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)Secant_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Secant_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Secant_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Secant, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Secant_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Secant, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Secant_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Secant_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Secant::solve(PyObject *,Real,Real,Real)\n"
    "    Secant::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Secant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Secant *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Secant", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Secant *)new Secant();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Secant, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Secant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Secant *arg1 = (Secant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Secant, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Secant" "', argument " "1"" of type '" "Secant *""'"); 
  }
  arg1 = reinterpret_cast< Secant * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Secant_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Secant, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Secant_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Newton_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Newton *arg1 = (Newton *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Newton_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Newton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Newton_setMaxEvaluations" "', argument " "1"" of type '" "Newton *""'"); 
  }
  arg1 = reinterpret_cast< Newton * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Newton_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Newton_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Newton *arg1 = (Newton *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Newton_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Newton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Newton_setLowerBound" "', argument " "1"" of type '" "Newton *""'"); 
  }
  arg1 = reinterpret_cast< Newton * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Newton_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Newton_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Newton *arg1 = (Newton *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Newton_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Newton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Newton_setUpperBound" "', argument " "1"" of type '" "Newton *""'"); 
  }
  arg1 = reinterpret_cast< Newton * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Newton_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Newton_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Newton *arg1 = (Newton *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Newton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Newton_solve" "', argument " "1"" of type '" "Newton *""'"); 
  }
  arg1 = reinterpret_cast< Newton * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Newton_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Newton_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Newton_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)Newton_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Newton_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Newton *arg1 = (Newton *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Newton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Newton_solve" "', argument " "1"" of type '" "Newton *""'"); 
  }
  arg1 = reinterpret_cast< Newton * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Newton_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Newton_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Newton_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Newton_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)Newton_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Newton_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Newton_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Newton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Newton_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Newton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Newton_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Newton_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Newton::solve(PyObject *,Real,Real,Real)\n"
    "    Newton::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Newton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Newton *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Newton", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Newton *)new Newton();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Newton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Newton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Newton *arg1 = (Newton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Newton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Newton" "', argument " "1"" of type '" "Newton *""'"); 
  }
  arg1 = reinterpret_cast< Newton * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Newton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Newton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Newton_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_NewtonSafe_setMaxEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NewtonSafe_setMaxEvaluations", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NewtonSafe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSafe_setMaxEvaluations" "', argument " "1"" of type '" "NewtonSafe *""'"); 
  }
  arg1 = reinterpret_cast< NewtonSafe * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewtonSafe_setMaxEvaluations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->setMaxEvaluations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewtonSafe_setLowerBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NewtonSafe_setLowerBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NewtonSafe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSafe_setLowerBound" "', argument " "1"" of type '" "NewtonSafe *""'"); 
  }
  arg1 = reinterpret_cast< NewtonSafe * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewtonSafe_setLowerBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setLowerBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewtonSafe_setUpperBound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "NewtonSafe_setUpperBound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NewtonSafe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSafe_setUpperBound" "', argument " "1"" of type '" "NewtonSafe *""'"); 
  }
  arg1 = reinterpret_cast< NewtonSafe * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewtonSafe_setUpperBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->setUpperBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewtonSafe_solve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NewtonSafe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSafe_solve" "', argument " "1"" of type '" "NewtonSafe *""'"); 
  }
  arg1 = reinterpret_cast< NewtonSafe * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NewtonSafe_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NewtonSafe_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "NewtonSafe_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)NewtonSafe_solve__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewtonSafe_solve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NewtonSafe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSafe_solve" "', argument " "1"" of type '" "NewtonSafe *""'"); 
  }
  arg1 = reinterpret_cast< NewtonSafe * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NewtonSafe_solve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NewtonSafe_solve" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "NewtonSafe_solve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "NewtonSafe_solve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)NewtonSafe_solve__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NewtonSafe_solve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "NewtonSafe_solve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_NewtonSafe, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_NewtonSafe_solve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_NewtonSafe, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_NewtonSafe_solve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NewtonSafe_solve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NewtonSafe::solve(PyObject *,Real,Real,Real)\n"
    "    NewtonSafe::solve(PyObject *,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_NewtonSafe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewtonSafe *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NewtonSafe", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (NewtonSafe *)new NewtonSafe();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NewtonSafe, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NewtonSafe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NewtonSafe *arg1 = (NewtonSafe *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NewtonSafe, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewtonSafe" "', argument " "1"" of type '" "NewtonSafe *""'"); 
  }
  arg1 = reinterpret_cast< NewtonSafe * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NewtonSafe_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_NewtonSafe, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NewtonSafe_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_Constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = (Constraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Constraint > tempshared1 ;
  ext::shared_ptr< Constraint > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Constraint" "', argument " "1"" of type '" "Constraint *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Constraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Constraint > * >(argp1);
      arg1 = const_cast< Constraint * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Constraint > * >(argp1);
      arg1 = const_cast< Constraint * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Constraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BoundaryConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BoundaryConstraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BoundaryConstraint", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoundaryConstraint" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BoundaryConstraint" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (BoundaryConstraint *)new BoundaryConstraint(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BoundaryConstraint > *smartresult = result ? new ext::shared_ptr<  BoundaryConstraint >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BoundaryConstraint_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoundaryConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoundaryConstraint *arg1 = (BoundaryConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BoundaryConstraint > tempshared1 ;
  ext::shared_ptr< BoundaryConstraint > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BoundaryConstraint_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryConstraint" "', argument " "1"" of type '" "BoundaryConstraint *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BoundaryConstraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BoundaryConstraint > * >(argp1);
      arg1 = const_cast< BoundaryConstraint * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BoundaryConstraint > * >(argp1);
      arg1 = const_cast< BoundaryConstraint * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoundaryConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BoundaryConstraint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BoundaryConstraint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoConstraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NoConstraint", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (NoConstraint *)new NoConstraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoConstraint > *smartresult = result ? new ext::shared_ptr<  NoConstraint >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoConstraint_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NoConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoConstraint *arg1 = (NoConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoConstraint > tempshared1 ;
  ext::shared_ptr< NoConstraint > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoConstraint_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoConstraint" "', argument " "1"" of type '" "NoConstraint *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NoConstraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NoConstraint > * >(argp1);
      arg1 = const_cast< NoConstraint * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NoConstraint > * >(argp1);
      arg1 = const_cast< NoConstraint * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NoConstraint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoConstraint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PositiveConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PositiveConstraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PositiveConstraint", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (PositiveConstraint *)new PositiveConstraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PositiveConstraint > *smartresult = result ? new ext::shared_ptr<  PositiveConstraint >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PositiveConstraint_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PositiveConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PositiveConstraint *arg1 = (PositiveConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PositiveConstraint > tempshared1 ;
  ext::shared_ptr< PositiveConstraint > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PositiveConstraint_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PositiveConstraint" "', argument " "1"" of type '" "PositiveConstraint *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PositiveConstraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PositiveConstraint > * >(argp1);
      arg1 = const_cast< PositiveConstraint * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PositiveConstraint > * >(argp1);
      arg1 = const_cast< PositiveConstraint * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PositiveConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PositiveConstraint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PositiveConstraint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CompositeConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Constraint *arg1 = 0 ;
  Constraint *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Constraint const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Constraint const > tempshared2 ;
  PyObject *swig_obj[2] ;
  CompositeConstraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CompositeConstraint", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeConstraint" "', argument " "1"" of type '" "Constraint const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeConstraint" "', argument " "1"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp1);
      arg1 = const_cast< Constraint * >(tempshared1.get());
    } else {
      arg1 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompositeConstraint" "', argument " "2"" of type '" "Constraint const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeConstraint" "', argument " "2"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2);
      arg2 = const_cast< Constraint * >(tempshared2.get());
    } else {
      arg2 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2)->get());
    }
  }
  {
    try {
      result = (CompositeConstraint *)new CompositeConstraint((Constraint const &)*arg1,(Constraint const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompositeConstraint > *smartresult = result ? new ext::shared_ptr<  CompositeConstraint >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompositeConstraint_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CompositeConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompositeConstraint *arg1 = (CompositeConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeConstraint > tempshared1 ;
  ext::shared_ptr< CompositeConstraint > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeConstraint_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositeConstraint" "', argument " "1"" of type '" "CompositeConstraint *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeConstraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeConstraint > * >(argp1);
      arg1 = const_cast< CompositeConstraint * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeConstraint > * >(argp1);
      arg1 = const_cast< CompositeConstraint * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompositeConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CompositeConstraint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompositeConstraint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NonhomogeneousBoundaryConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  NonhomogeneousBoundaryConstraint *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NonhomogeneousBoundaryConstraint", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonhomogeneousBoundaryConstraint" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonhomogeneousBoundaryConstraint" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonhomogeneousBoundaryConstraint" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonhomogeneousBoundaryConstraint" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (NonhomogeneousBoundaryConstraint *)new NonhomogeneousBoundaryConstraint((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonhomogeneousBoundaryConstraint > *smartresult = result ? new ext::shared_ptr<  NonhomogeneousBoundaryConstraint >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NonhomogeneousBoundaryConstraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonhomogeneousBoundaryConstraint *arg1 = (NonhomogeneousBoundaryConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonhomogeneousBoundaryConstraint > tempshared1 ;
  ext::shared_ptr< NonhomogeneousBoundaryConstraint > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonhomogeneousBoundaryConstraint" "', argument " "1"" of type '" "NonhomogeneousBoundaryConstraint *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NonhomogeneousBoundaryConstraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NonhomogeneousBoundaryConstraint > * >(argp1);
      arg1 = const_cast< NonhomogeneousBoundaryConstraint * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NonhomogeneousBoundaryConstraint > * >(argp1);
      arg1 = const_cast< NonhomogeneousBoundaryConstraint * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NonhomogeneousBoundaryConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NonhomogeneousBoundaryConstraint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EndCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  EndCriteria *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EndCriteria", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EndCriteria" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EndCriteria" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EndCriteria" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_EndCriteria" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_EndCriteria" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (EndCriteria *)new EndCriteria(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EndCriteria > *smartresult = result ? new ext::shared_ptr<  EndCriteria >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EndCriteria___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EndCriteria *arg1 = (EndCriteria *) 0 ;
  Size arg2 ;
  Size *arg3 = 0 ;
  bool arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  EndCriteria::Type *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared1 ;
  ext::shared_ptr< EndCriteria const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject *swig_obj[9] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "EndCriteria___call__", 9, 9, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EndCriteria___call__" "', argument " "1"" of type '" "EndCriteria const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp1);
      arg1 = const_cast< EndCriteria * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp1);
      arg1 = const_cast< EndCriteria * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EndCriteria___call__" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_size_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EndCriteria___call__" "', argument " "3"" of type '" "Size &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EndCriteria___call__" "', argument " "3"" of type '" "Size &""'"); 
  }
  arg3 = reinterpret_cast< Size * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EndCriteria___call__" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "EndCriteria___call__" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "EndCriteria___call__" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "EndCriteria___call__" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "EndCriteria___call__" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_EndCriteria__Type,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "EndCriteria___call__" "', argument " "9"" of type '" "EndCriteria::Type &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EndCriteria___call__" "', argument " "9"" of type '" "EndCriteria::Type &""'"); 
  }
  arg9 = reinterpret_cast< EndCriteria::Type * >(argp9);
  {
    try {
      result = (bool)((EndCriteria const *)arg1)->operator ()(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EndCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EndCriteria *arg1 = (EndCriteria *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared1 ;
  ext::shared_ptr< EndCriteria > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndCriteria" "', argument " "1"" of type '" "EndCriteria *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EndCriteria > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EndCriteria > * >(argp1);
      arg1 = const_cast< EndCriteria * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EndCriteria > * >(argp1);
      arg1 = const_cast< EndCriteria * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EndCriteria_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EndCriteria_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_OptimizationMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptimizationMethod *arg1 = (OptimizationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared1 ;
  ext::shared_ptr< OptimizationMethod > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationMethod" "', argument " "1"" of type '" "OptimizationMethod *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp1);
      arg1 = const_cast< OptimizationMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp1);
      arg1 = const_cast< OptimizationMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptimizationMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ConjugateGradient(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConjugateGradient *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ConjugateGradient", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ConjugateGradient *)new ConjugateGradient();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConjugateGradient > *smartresult = result ? new ext::shared_ptr<  ConjugateGradient >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConjugateGradient_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConjugateGradient(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConjugateGradient *arg1 = (ConjugateGradient *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConjugateGradient > tempshared1 ;
  ext::shared_ptr< ConjugateGradient > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConjugateGradient_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConjugateGradient" "', argument " "1"" of type '" "ConjugateGradient *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConjugateGradient > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConjugateGradient > * >(argp1);
      arg1 = const_cast< ConjugateGradient * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConjugateGradient > * >(argp1);
      arg1 = const_cast< ConjugateGradient * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConjugateGradient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConjugateGradient_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConjugateGradient_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Simplex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Simplex *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Simplex" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (Simplex *)new Simplex(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Simplex > *smartresult = result ? new ext::shared_ptr<  Simplex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Simplex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Simplex_getLambda(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Simplex *arg1 = (Simplex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Simplex > tempshared1 ;
  ext::shared_ptr< Simplex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Simplex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Simplex_getLambda" "', argument " "1"" of type '" "Simplex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Simplex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Simplex > * >(argp1);
      arg1 = const_cast< Simplex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Simplex > * >(argp1);
      arg1 = const_cast< Simplex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->lambda();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Simplex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Simplex *arg1 = (Simplex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Simplex > tempshared1 ;
  ext::shared_ptr< Simplex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Simplex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Simplex" "', argument " "1"" of type '" "Simplex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Simplex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Simplex > * >(argp1);
      arg1 = const_cast< Simplex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Simplex > * >(argp1);
      arg1 = const_cast< Simplex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Simplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Simplex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Simplex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SteepestDescent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SteepestDescent *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SteepestDescent", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (SteepestDescent *)new SteepestDescent();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SteepestDescent > *smartresult = result ? new ext::shared_ptr<  SteepestDescent >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SteepestDescent_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SteepestDescent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SteepestDescent *arg1 = (SteepestDescent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SteepestDescent > tempshared1 ;
  ext::shared_ptr< SteepestDescent > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SteepestDescent_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SteepestDescent" "', argument " "1"" of type '" "SteepestDescent *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SteepestDescent > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SteepestDescent > * >(argp1);
      arg1 = const_cast< SteepestDescent * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SteepestDescent > * >(argp1);
      arg1 = const_cast< SteepestDescent * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SteepestDescent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SteepestDescent_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SteepestDescent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BFGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BFGS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BFGS", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (BFGS *)new BFGS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BFGS > *smartresult = result ? new ext::shared_ptr<  BFGS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BFGS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BFGS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BFGS *arg1 = (BFGS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BFGS > tempshared1 ;
  ext::shared_ptr< BFGS > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BFGS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BFGS" "', argument " "1"" of type '" "BFGS *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BFGS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BFGS > * >(argp1);
      arg1 = const_cast< BFGS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BFGS > * >(argp1);
      arg1 = const_cast< BFGS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BFGS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BFGS_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BFGS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LevenbergMarquardt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  LevenbergMarquardt *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LevenbergMarquardt" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LevenbergMarquardt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LevenbergMarquardt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LevenbergMarquardt" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LevenbergMarquardt > *smartresult = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LevenbergMarquardt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  LevenbergMarquardt *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LevenbergMarquardt" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LevenbergMarquardt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LevenbergMarquardt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LevenbergMarquardt > *smartresult = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LevenbergMarquardt__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  LevenbergMarquardt *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LevenbergMarquardt" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LevenbergMarquardt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LevenbergMarquardt > *smartresult = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LevenbergMarquardt__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  LevenbergMarquardt *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LevenbergMarquardt" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LevenbergMarquardt > *smartresult = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LevenbergMarquardt__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  LevenbergMarquardt *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (LevenbergMarquardt *)new LevenbergMarquardt();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LevenbergMarquardt > *smartresult = result ? new ext::shared_ptr<  LevenbergMarquardt >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LevenbergMarquardt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LevenbergMarquardt", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LevenbergMarquardt__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LevenbergMarquardt__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LevenbergMarquardt__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_LevenbergMarquardt__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LevenbergMarquardt__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LevenbergMarquardt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LevenbergMarquardt::LevenbergMarquardt(Real,Real,Real,bool)\n"
    "    LevenbergMarquardt::LevenbergMarquardt(Real,Real,Real)\n"
    "    LevenbergMarquardt::LevenbergMarquardt(Real,Real)\n"
    "    LevenbergMarquardt::LevenbergMarquardt(Real)\n"
    "    LevenbergMarquardt::LevenbergMarquardt()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LevenbergMarquardt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LevenbergMarquardt *arg1 = (LevenbergMarquardt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LevenbergMarquardt > tempshared1 ;
  ext::shared_ptr< LevenbergMarquardt > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LevenbergMarquardt" "', argument " "1"" of type '" "LevenbergMarquardt *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LevenbergMarquardt > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LevenbergMarquardt > * >(argp1);
      arg1 = const_cast< LevenbergMarquardt * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LevenbergMarquardt > * >(argp1);
      arg1 = const_cast< LevenbergMarquardt * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LevenbergMarquardt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LevenbergMarquardt_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LevenbergMarquardt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DifferentialEvolution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DifferentialEvolution *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DifferentialEvolution", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (DifferentialEvolution *)new DifferentialEvolution();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DifferentialEvolution > *smartresult = result ? new ext::shared_ptr<  DifferentialEvolution >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DifferentialEvolution_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DifferentialEvolution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DifferentialEvolution *arg1 = (DifferentialEvolution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DifferentialEvolution > tempshared1 ;
  ext::shared_ptr< DifferentialEvolution > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DifferentialEvolution_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DifferentialEvolution" "', argument " "1"" of type '" "DifferentialEvolution *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DifferentialEvolution > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DifferentialEvolution > * >(argp1);
      arg1 = const_cast< DifferentialEvolution * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DifferentialEvolution > * >(argp1);
      arg1 = const_cast< DifferentialEvolution * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DifferentialEvolution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DifferentialEvolution_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DifferentialEvolution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SamplerGaussian__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned long arg1 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  SamplerGaussian *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SamplerGaussian" "', argument " "1"" of type '" "unsigned long""'");
  } 
  arg1 = static_cast< unsigned long >(val1);
  {
    try {
      result = (SamplerGaussian *)new SamplerGaussian(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SamplerGaussian__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SamplerGaussian *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (SamplerGaussian *)new SamplerGaussian();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SamplerGaussian(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SamplerGaussian", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SamplerGaussian__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SamplerGaussian__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SamplerGaussian'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SamplerGaussian::SamplerGaussian(unsigned long)\n"
    "    SamplerGaussian::SamplerGaussian()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SamplerGaussian(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = (SamplerGaussian *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplerGaussian" "', argument " "1"" of type '" "SamplerGaussian *""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SamplerGaussian_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SamplerGaussian, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SamplerGaussian_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SamplerLogNormal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned long arg1 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  SamplerLogNormal *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SamplerLogNormal" "', argument " "1"" of type '" "unsigned long""'");
  } 
  arg1 = static_cast< unsigned long >(val1);
  {
    try {
      result = (SamplerLogNormal *)new SamplerLogNormal(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SamplerLogNormal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SamplerLogNormal *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (SamplerLogNormal *)new SamplerLogNormal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SamplerLogNormal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SamplerLogNormal", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SamplerLogNormal__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SamplerLogNormal__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SamplerLogNormal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SamplerLogNormal::SamplerLogNormal(unsigned long)\n"
    "    SamplerLogNormal::SamplerLogNormal()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SamplerLogNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = (SamplerLogNormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplerLogNormal" "', argument " "1"" of type '" "SamplerLogNormal *""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SamplerLogNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SamplerLogNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SamplerLogNormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SamplerMirrorGaussian__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  unsigned long arg3 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  SamplerMirrorGaussian *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SamplerMirrorGaussian" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SamplerMirrorGaussian" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SamplerMirrorGaussian" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SamplerMirrorGaussian" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SamplerMirrorGaussian" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);
  {
    try {
      result = (SamplerMirrorGaussian *)new SamplerMirrorGaussian((Array const &)*arg1,(Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SamplerMirrorGaussian__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SamplerMirrorGaussian *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SamplerMirrorGaussian" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SamplerMirrorGaussian" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SamplerMirrorGaussian" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SamplerMirrorGaussian" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SamplerMirrorGaussian *)new SamplerMirrorGaussian((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SamplerMirrorGaussian(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SamplerMirrorGaussian", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_new_SamplerMirrorGaussian__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SamplerMirrorGaussian__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SamplerMirrorGaussian'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SamplerMirrorGaussian::SamplerMirrorGaussian(Array const &,Array const &,unsigned long)\n"
    "    SamplerMirrorGaussian::SamplerMirrorGaussian(Array const &,Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SamplerMirrorGaussian(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = (SamplerMirrorGaussian *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplerMirrorGaussian" "', argument " "1"" of type '" "SamplerMirrorGaussian *""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SamplerMirrorGaussian_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SamplerMirrorGaussian, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SamplerMirrorGaussian_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ProbabilityBoltzmannDownhill__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned long arg1 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  ProbabilityBoltzmannDownhill *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProbabilityBoltzmannDownhill" "', argument " "1"" of type '" "unsigned long""'");
  } 
  arg1 = static_cast< unsigned long >(val1);
  {
    try {
      result = (ProbabilityBoltzmannDownhill *)new ProbabilityBoltzmannDownhill(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProbabilityBoltzmannDownhill__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ProbabilityBoltzmannDownhill *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ProbabilityBoltzmannDownhill *)new ProbabilityBoltzmannDownhill();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProbabilityBoltzmannDownhill(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ProbabilityBoltzmannDownhill", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ProbabilityBoltzmannDownhill__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ProbabilityBoltzmannDownhill__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ProbabilityBoltzmannDownhill'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ProbabilityBoltzmannDownhill::ProbabilityBoltzmannDownhill(unsigned long)\n"
    "    ProbabilityBoltzmannDownhill::ProbabilityBoltzmannDownhill()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProbabilityBoltzmannDownhill(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ProbabilityBoltzmannDownhill *arg1 = (ProbabilityBoltzmannDownhill *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProbabilityBoltzmannDownhill" "', argument " "1"" of type '" "ProbabilityBoltzmannDownhill *""'"); 
  }
  arg1 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProbabilityBoltzmannDownhill_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ProbabilityBoltzmannDownhill_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TemperatureExponential__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  TemperatureExponential *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TemperatureExponential" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TemperatureExponential" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TemperatureExponential" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (TemperatureExponential *)new TemperatureExponential(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TemperatureExponential__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TemperatureExponential *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TemperatureExponential" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TemperatureExponential" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TemperatureExponential *)new TemperatureExponential(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TemperatureExponential(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TemperatureExponential", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TemperatureExponential__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TemperatureExponential__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TemperatureExponential'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TemperatureExponential::TemperatureExponential(Real,Size,Real)\n"
    "    TemperatureExponential::TemperatureExponential(Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TemperatureExponential(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TemperatureExponential *arg1 = (TemperatureExponential *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TemperatureExponential" "', argument " "1"" of type '" "TemperatureExponential *""'"); 
  }
  arg1 = reinterpret_cast< TemperatureExponential * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TemperatureExponential_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TemperatureExponential, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TemperatureExponential_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ReannealingTrivial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReannealingTrivial *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ReannealingTrivial", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ReannealingTrivial *)new ReannealingTrivial();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ReannealingTrivial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ReannealingTrivial *arg1 = (ReannealingTrivial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReannealingTrivial" "', argument " "1"" of type '" "ReannealingTrivial *""'"); 
  }
  arg1 = reinterpret_cast< ReannealingTrivial * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReannealingTrivial_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ReannealingTrivial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ReannealingTrivial_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  GaussianSimulatedAnnealing::ResetScheme arg8 ;
  Size arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "8"" of type '" "GaussianSimulatedAnnealing::ResetScheme""'");
  } 
  arg8 = static_cast< GaussianSimulatedAnnealing::ResetScheme >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  GaussianSimulatedAnnealing::ResetScheme arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "8"" of type '" "GaussianSimulatedAnnealing::ResetScheme""'");
  } 
  arg8 = static_cast< GaussianSimulatedAnnealing::ResetScheme >(val8);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  GaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  {
    try {
      result = (GaussianSimulatedAnnealing *)new GaussianSimulatedAnnealing((SamplerGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  GaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSimulatedAnnealing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussianSimulatedAnnealing", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_GaussianSimulatedAnnealing__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_GaussianSimulatedAnnealing__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_GaussianSimulatedAnnealing__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_GaussianSimulatedAnnealing__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_GaussianSimulatedAnnealing__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_GaussianSimulatedAnnealing__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_GaussianSimulatedAnnealing__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussianSimulatedAnnealing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size,GaussianSimulatedAnnealing::ResetScheme,Size)\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size,GaussianSimulatedAnnealing::ResetScheme)\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size)\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real)\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real)\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &)\n"
    "    GaussianSimulatedAnnealing::GaussianSimulatedAnnealing(SamplerGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GaussianSimulatedAnnealing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianSimulatedAnnealing *arg1 = (GaussianSimulatedAnnealing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GaussianSimulatedAnnealing > tempshared1 ;
  ext::shared_ptr< GaussianSimulatedAnnealing > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianSimulatedAnnealing" "', argument " "1"" of type '" "GaussianSimulatedAnnealing *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GaussianSimulatedAnnealing > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GaussianSimulatedAnnealing > * >(argp1);
      arg1 = const_cast< GaussianSimulatedAnnealing * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GaussianSimulatedAnnealing > * >(argp1);
      arg1 = const_cast< GaussianSimulatedAnnealing * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianSimulatedAnnealing_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GaussianSimulatedAnnealing_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianSimulatedAnnealing_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  MirrorGaussianSimulatedAnnealing::ResetScheme arg8 ;
  Size arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "8"" of type '" "MirrorGaussianSimulatedAnnealing::ResetScheme""'");
  } 
  arg8 = static_cast< MirrorGaussianSimulatedAnnealing::ResetScheme >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  MirrorGaussianSimulatedAnnealing::ResetScheme arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "8"" of type '" "MirrorGaussianSimulatedAnnealing::ResetScheme""'");
  } 
  arg8 = static_cast< MirrorGaussianSimulatedAnnealing::ResetScheme >(val8);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerMirrorGaussian *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  MirrorGaussianSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerMirrorGaussian,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "SamplerMirrorGaussian const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerMirrorGaussian * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MirrorGaussianSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  {
    try {
      result = (MirrorGaussianSimulatedAnnealing *)new MirrorGaussianSimulatedAnnealing((SamplerMirrorGaussian const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  MirrorGaussianSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MirrorGaussianSimulatedAnnealing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MirrorGaussianSimulatedAnnealing", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerMirrorGaussian, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_MirrorGaussianSimulatedAnnealing__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MirrorGaussianSimulatedAnnealing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size,MirrorGaussianSimulatedAnnealing::ResetScheme,Size)\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size,MirrorGaussianSimulatedAnnealing::ResetScheme)\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size)\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real)\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real)\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &)\n"
    "    MirrorGaussianSimulatedAnnealing::MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MirrorGaussianSimulatedAnnealing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MirrorGaussianSimulatedAnnealing *arg1 = (MirrorGaussianSimulatedAnnealing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MirrorGaussianSimulatedAnnealing > tempshared1 ;
  ext::shared_ptr< MirrorGaussianSimulatedAnnealing > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MirrorGaussianSimulatedAnnealing" "', argument " "1"" of type '" "MirrorGaussianSimulatedAnnealing *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > * >(argp1);
      arg1 = const_cast< MirrorGaussianSimulatedAnnealing * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MirrorGaussianSimulatedAnnealing > * >(argp1);
      arg1 = const_cast< MirrorGaussianSimulatedAnnealing * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MirrorGaussianSimulatedAnnealing_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MirrorGaussianSimulatedAnnealing_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  LogNormalSimulatedAnnealing::ResetScheme arg8 ;
  Size arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "8"" of type '" "LogNormalSimulatedAnnealing::ResetScheme""'");
  } 
  arg8 = static_cast< LogNormalSimulatedAnnealing::ResetScheme >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  LogNormalSimulatedAnnealing::ResetScheme arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "8"" of type '" "LogNormalSimulatedAnnealing::ResetScheme""'");
  } 
  arg8 = static_cast< LogNormalSimulatedAnnealing::ResetScheme >(val8);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  ReannealingTrivial *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ReannealingTrivial,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "4"" of type '" "ReannealingTrivial const &""'"); 
  }
  arg4 = reinterpret_cast< ReannealingTrivial * >(argp4);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3,(ReannealingTrivial const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SamplerLogNormal *arg1 = 0 ;
  ProbabilityBoltzmannDownhill *arg2 = 0 ;
  TemperatureExponential *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  LogNormalSimulatedAnnealing *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SamplerLogNormal,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "SamplerLogNormal const &""'"); 
  }
  arg1 = reinterpret_cast< SamplerLogNormal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ProbabilityBoltzmannDownhill,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "2"" of type '" "ProbabilityBoltzmannDownhill const &""'"); 
  }
  arg2 = reinterpret_cast< ProbabilityBoltzmannDownhill * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TemperatureExponential,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalSimulatedAnnealing" "', argument " "3"" of type '" "TemperatureExponential const &""'"); 
  }
  arg3 = reinterpret_cast< TemperatureExponential * >(argp3);
  {
    try {
      result = (LogNormalSimulatedAnnealing *)new LogNormalSimulatedAnnealing((SamplerLogNormal const &)*arg1,(ProbabilityBoltzmannDownhill const &)*arg2,(TemperatureExponential const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalSimulatedAnnealing > *smartresult = result ? new ext::shared_ptr<  LogNormalSimulatedAnnealing >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalSimulatedAnnealing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LogNormalSimulatedAnnealing", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LogNormalSimulatedAnnealing__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LogNormalSimulatedAnnealing__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_LogNormalSimulatedAnnealing__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_LogNormalSimulatedAnnealing__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LogNormalSimulatedAnnealing__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_LogNormalSimulatedAnnealing__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SamplerLogNormal, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ProbabilityBoltzmannDownhill, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_TemperatureExponential, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ReannealingTrivial, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_LogNormalSimulatedAnnealing__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LogNormalSimulatedAnnealing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size,LogNormalSimulatedAnnealing::ResetScheme,Size)\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size,LogNormalSimulatedAnnealing::ResetScheme)\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real,Size)\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real,Real)\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &,Real)\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &,ReannealingTrivial const &)\n"
    "    LogNormalSimulatedAnnealing::LogNormalSimulatedAnnealing(SamplerLogNormal const &,ProbabilityBoltzmannDownhill const &,TemperatureExponential const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LogNormalSimulatedAnnealing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogNormalSimulatedAnnealing *arg1 = (LogNormalSimulatedAnnealing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LogNormalSimulatedAnnealing > tempshared1 ;
  ext::shared_ptr< LogNormalSimulatedAnnealing > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNormalSimulatedAnnealing" "', argument " "1"" of type '" "LogNormalSimulatedAnnealing *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LogNormalSimulatedAnnealing > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LogNormalSimulatedAnnealing > * >(argp1);
      arg1 = const_cast< LogNormalSimulatedAnnealing * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LogNormalSimulatedAnnealing > * >(argp1);
      arg1 = const_cast< LogNormalSimulatedAnnealing * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogNormalSimulatedAnnealing_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogNormalSimulatedAnnealing_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Optimizer_solve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Optimizer *arg1 = (Optimizer *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Constraint *arg3 = 0 ;
  OptimizationMethod *arg4 = 0 ;
  EndCriteria *arg5 = 0 ;
  Array *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< Constraint > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "Optimizer_solve", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Optimizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Optimizer_solve" "', argument " "1"" of type '" "Optimizer *""'"); 
  }
  arg1 = reinterpret_cast< Optimizer * >(argp1);
  arg2 = swig_obj[1];
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Optimizer_solve" "', argument " "3"" of type '" "Constraint &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Optimizer_solve" "', argument " "3"" of type '" "Constraint &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  Constraint > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  Constraint > * >(argp3);
      arg3 = const_cast< Constraint * >(tempshared3.get());
    } else {
      arg3 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr<  Constraint > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Optimizer_solve" "', argument " "4"" of type '" "OptimizationMethod &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Optimizer_solve" "', argument " "4"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp4);
      arg4 = const_cast< OptimizationMethod * >(tempshared4.get());
    } else {
      arg4 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Optimizer_solve" "', argument " "5"" of type '" "EndCriteria &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Optimizer_solve" "', argument " "5"" of type '" "EndCriteria &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr<  EndCriteria > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr<  EndCriteria > * >(argp5);
      arg5 = const_cast< EndCriteria * >(tempshared5.get());
    } else {
      arg5 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr<  EndCriteria > * >(argp5)->get());
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Optimizer_solve" "', argument " "6"" of type '" "Array &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Optimizer_solve" "', argument " "6"" of type '" "Array &""'"); 
  }
  arg6 = reinterpret_cast< Array * >(argp6);
  {
    try {
      result = Optimizer_solve(arg1,arg2,*arg3,*arg4,*arg5,*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Optimizer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Optimizer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Optimizer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Optimizer *)new Optimizer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Optimizer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Optimizer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Optimizer *arg1 = (Optimizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Optimizer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Optimizer" "', argument " "1"" of type '" "Optimizer *""'"); 
  }
  arg1 = reinterpret_cast< Optimizer * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Optimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Optimizer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Optimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LinearInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeLinearInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LinearInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeLinearInterpolation *)new SafeLinearInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeLinearInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLinearInterpolation *arg1 = (SafeLinearInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLinearInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearInterpolation___call__" "', argument " "1"" of type '" "SafeLinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLinearInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLinearInterpolation *arg1 = (SafeLinearInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLinearInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearInterpolation___call__" "', argument " "1"" of type '" "SafeLinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLinearInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LinearInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLinearInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinearInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLinearInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LinearInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLinearInterpolation::operator ()(Real,bool)\n"
    "    SafeLinearInterpolation::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LinearInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeLinearInterpolation *arg1 = (SafeLinearInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLinearInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearInterpolation" "', argument " "1"" of type '" "SafeLinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLinearInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LinearInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeLinearInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LinearInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogLinearInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeLogLinearInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogLinearInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogLinearInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogLinearInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeLogLinearInterpolation *)new SafeLogLinearInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeLogLinearInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogLinearInterpolation *arg1 = (SafeLogLinearInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogLinearInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearInterpolation___call__" "', argument " "1"" of type '" "SafeLogLinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogLinearInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogLinearInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogLinearInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogLinearInterpolation *arg1 = (SafeLogLinearInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogLinearInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearInterpolation___call__" "', argument " "1"" of type '" "SafeLogLinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogLinearInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogLinearInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogLinearInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogLinearInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogLinearInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogLinearInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogLinearInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogLinearInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogLinearInterpolation::operator ()(Real,bool)\n"
    "    SafeLogLinearInterpolation::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LogLinearInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeLogLinearInterpolation *arg1 = (SafeLogLinearInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogLinearInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogLinearInterpolation" "', argument " "1"" of type '" "SafeLogLinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogLinearInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogLinearInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeLogLinearInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogLinearInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BackwardFlatInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeBackwardFlatInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BackwardFlatInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BackwardFlatInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BackwardFlatInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BackwardFlatInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BackwardFlatInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeBackwardFlatInterpolation *)new SafeBackwardFlatInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeBackwardFlatInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BackwardFlatInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeBackwardFlatInterpolation *arg1 = (SafeBackwardFlatInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBackwardFlatInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardFlatInterpolation___call__" "', argument " "1"" of type '" "SafeBackwardFlatInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeBackwardFlatInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BackwardFlatInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BackwardFlatInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BackwardFlatInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeBackwardFlatInterpolation *arg1 = (SafeBackwardFlatInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBackwardFlatInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardFlatInterpolation___call__" "', argument " "1"" of type '" "SafeBackwardFlatInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeBackwardFlatInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BackwardFlatInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BackwardFlatInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BackwardFlatInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeBackwardFlatInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BackwardFlatInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeBackwardFlatInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BackwardFlatInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BackwardFlatInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeBackwardFlatInterpolation::operator ()(Real,bool)\n"
    "    SafeBackwardFlatInterpolation::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BackwardFlatInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeBackwardFlatInterpolation *arg1 = (SafeBackwardFlatInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBackwardFlatInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackwardFlatInterpolation" "', argument " "1"" of type '" "SafeBackwardFlatInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeBackwardFlatInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BackwardFlatInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeBackwardFlatInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BackwardFlatInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardFlatInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeForwardFlatInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ForwardFlatInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardFlatInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardFlatInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardFlatInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardFlatInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeForwardFlatInterpolation *)new SafeForwardFlatInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeForwardFlatInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardFlatInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeForwardFlatInterpolation *arg1 = (SafeForwardFlatInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeForwardFlatInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardFlatInterpolation___call__" "', argument " "1"" of type '" "SafeForwardFlatInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeForwardFlatInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ForwardFlatInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ForwardFlatInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardFlatInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeForwardFlatInterpolation *arg1 = (SafeForwardFlatInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeForwardFlatInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardFlatInterpolation___call__" "', argument " "1"" of type '" "SafeForwardFlatInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeForwardFlatInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ForwardFlatInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardFlatInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ForwardFlatInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeForwardFlatInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ForwardFlatInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeForwardFlatInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ForwardFlatInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ForwardFlatInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeForwardFlatInterpolation::operator ()(Real,bool)\n"
    "    SafeForwardFlatInterpolation::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ForwardFlatInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeForwardFlatInterpolation *arg1 = (SafeForwardFlatInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeForwardFlatInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardFlatInterpolation" "', argument " "1"" of type '" "SafeForwardFlatInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeForwardFlatInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardFlatInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeForwardFlatInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardFlatInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeCubicNaturalSpline *)new SafeCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeCubicNaturalSpline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CubicNaturalSpline___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CubicNaturalSpline___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CubicNaturalSpline___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicNaturalSpline___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CubicNaturalSpline___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeCubicNaturalSpline::operator ()(Real,bool)\n"
    "    SafeCubicNaturalSpline::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CubicNaturalSpline_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CubicNaturalSpline_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CubicNaturalSpline_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicNaturalSpline_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CubicNaturalSpline_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeCubicNaturalSpline::derivative(Real,bool)\n"
    "    SafeCubicNaturalSpline::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CubicNaturalSpline_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CubicNaturalSpline_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CubicNaturalSpline_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicNaturalSpline_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CubicNaturalSpline_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeCubicNaturalSpline::secondDerivative(Real,bool)\n"
    "    SafeCubicNaturalSpline::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CubicNaturalSpline_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicNaturalSpline_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CubicNaturalSpline_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CubicNaturalSpline_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicNaturalSpline_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CubicNaturalSpline_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeCubicNaturalSpline::primitive(Real,bool)\n"
    "    SafeCubicNaturalSpline::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeCubicNaturalSpline *arg1 = (SafeCubicNaturalSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeCubicNaturalSpline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CubicNaturalSpline" "', argument " "1"" of type '" "SafeCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeCubicNaturalSpline * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CubicNaturalSpline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeCubicNaturalSpline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CubicNaturalSpline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogCubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeLogCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogCubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogCubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogCubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeLogCubicNaturalSpline *)new SafeLogCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeLogCubicNaturalSpline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogCubicNaturalSpline___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogCubicNaturalSpline___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogCubicNaturalSpline___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogCubicNaturalSpline___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogCubicNaturalSpline___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogCubicNaturalSpline::operator ()(Real,bool)\n"
    "    SafeLogCubicNaturalSpline::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogCubicNaturalSpline_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogCubicNaturalSpline_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogCubicNaturalSpline_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogCubicNaturalSpline_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogCubicNaturalSpline_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogCubicNaturalSpline::derivative(Real,bool)\n"
    "    SafeLogCubicNaturalSpline::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogCubicNaturalSpline_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogCubicNaturalSpline_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogCubicNaturalSpline_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogCubicNaturalSpline_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogCubicNaturalSpline_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogCubicNaturalSpline::secondDerivative(Real,bool)\n"
    "    SafeLogCubicNaturalSpline::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogCubicNaturalSpline_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogCubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicNaturalSpline_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogCubicNaturalSpline_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogCubicNaturalSpline_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogCubicNaturalSpline_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogCubicNaturalSpline_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogCubicNaturalSpline::primitive(Real,bool)\n"
    "    SafeLogCubicNaturalSpline::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LogCubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeLogCubicNaturalSpline *arg1 = (SafeLogCubicNaturalSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogCubicNaturalSpline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogCubicNaturalSpline" "', argument " "1"" of type '" "SafeLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogCubicNaturalSpline * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogCubicNaturalSpline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeLogCubicNaturalSpline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogCubicNaturalSpline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicCubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicCubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeMonotonicCubicNaturalSpline *)new SafeMonotonicCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicCubicNaturalSpline___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicCubicNaturalSpline___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicCubicNaturalSpline___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicCubicNaturalSpline___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicCubicNaturalSpline___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicCubicNaturalSpline::operator ()(Real,bool)\n"
    "    SafeMonotonicCubicNaturalSpline::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicCubicNaturalSpline_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicCubicNaturalSpline_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicCubicNaturalSpline_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicCubicNaturalSpline_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicCubicNaturalSpline_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicCubicNaturalSpline::derivative(Real,bool)\n"
    "    SafeMonotonicCubicNaturalSpline::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicCubicNaturalSpline_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicCubicNaturalSpline_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicCubicNaturalSpline_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicCubicNaturalSpline_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicCubicNaturalSpline_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicCubicNaturalSpline::secondDerivative(Real,bool)\n"
    "    SafeMonotonicCubicNaturalSpline::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicCubicNaturalSpline_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicCubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicNaturalSpline_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicCubicNaturalSpline_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicCubicNaturalSpline_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicCubicNaturalSpline_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicCubicNaturalSpline_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicCubicNaturalSpline::primitive(Real,bool)\n"
    "    SafeMonotonicCubicNaturalSpline::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicCubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeMonotonicCubicNaturalSpline *arg1 = (SafeMonotonicCubicNaturalSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicCubicNaturalSpline" "', argument " "1"" of type '" "SafeMonotonicCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicCubicNaturalSpline * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicCubicNaturalSpline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeMonotonicCubicNaturalSpline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicCubicNaturalSpline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicLogCubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicLogCubicNaturalSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicLogCubicNaturalSpline", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicLogCubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicNaturalSpline" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicLogCubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicNaturalSpline" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeMonotonicLogCubicNaturalSpline *)new SafeMonotonicLogCubicNaturalSpline((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogCubicNaturalSpline___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline___call__" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogCubicNaturalSpline___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogCubicNaturalSpline___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogCubicNaturalSpline___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogCubicNaturalSpline___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogCubicNaturalSpline::operator ()(Real,bool)\n"
    "    SafeMonotonicLogCubicNaturalSpline::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogCubicNaturalSpline_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline_derivative" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogCubicNaturalSpline_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogCubicNaturalSpline_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogCubicNaturalSpline_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogCubicNaturalSpline_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogCubicNaturalSpline::derivative(Real,bool)\n"
    "    SafeMonotonicLogCubicNaturalSpline::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogCubicNaturalSpline_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogCubicNaturalSpline_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogCubicNaturalSpline_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogCubicNaturalSpline_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogCubicNaturalSpline_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogCubicNaturalSpline::secondDerivative(Real,bool)\n"
    "    SafeMonotonicLogCubicNaturalSpline::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogCubicNaturalSpline_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicNaturalSpline_primitive" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogCubicNaturalSpline_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicLogCubicNaturalSpline_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicNaturalSpline_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogCubicNaturalSpline_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogCubicNaturalSpline_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogCubicNaturalSpline_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogCubicNaturalSpline_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogCubicNaturalSpline::primitive(Real,bool)\n"
    "    SafeMonotonicLogCubicNaturalSpline::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicLogCubicNaturalSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeMonotonicLogCubicNaturalSpline *arg1 = (SafeMonotonicLogCubicNaturalSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicLogCubicNaturalSpline" "', argument " "1"" of type '" "SafeMonotonicLogCubicNaturalSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogCubicNaturalSpline * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicLogCubicNaturalSpline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeMonotonicLogCubicNaturalSpline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicLogCubicNaturalSpline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KrugerCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeKrugerCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KrugerCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerCubic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerCubic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerCubic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerCubic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeKrugerCubic *)new SafeKrugerCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeKrugerCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic___call__" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerCubic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic___call__" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerCubic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerCubic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerCubic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerCubic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerCubic::operator ()(Real,bool)\n"
    "    SafeKrugerCubic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic_derivative" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerCubic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeKrugerCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic_derivative" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeKrugerCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerCubic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerCubic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerCubic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerCubic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerCubic::derivative(Real,bool)\n"
    "    SafeKrugerCubic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic_secondDerivative" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerCubic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeKrugerCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic_secondDerivative" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeKrugerCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerCubic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerCubic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerCubic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerCubic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerCubic::secondDerivative(Real,bool)\n"
    "    SafeKrugerCubic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic_primitive" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerCubic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeKrugerCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerCubic_primitive" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeKrugerCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerCubic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerCubic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerCubic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerCubic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerCubic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerCubic::primitive(Real,bool)\n"
    "    SafeKrugerCubic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_KrugerCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeKrugerCubic *arg1 = (SafeKrugerCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KrugerCubic" "', argument " "1"" of type '" "SafeKrugerCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KrugerCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeKrugerCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KrugerCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KrugerLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeKrugerLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KrugerLogCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerLogCubic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogCubic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerLogCubic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogCubic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeKrugerLogCubic *)new SafeKrugerLogCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeKrugerLogCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic___call__" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerLogCubic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic___call__" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerLogCubic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerLogCubic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerLogCubic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerLogCubic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerLogCubic::operator ()(Real,bool)\n"
    "    SafeKrugerLogCubic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic_derivative" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerLogCubic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeKrugerLogCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic_derivative" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeKrugerLogCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerLogCubic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerLogCubic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerLogCubic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerLogCubic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerLogCubic::derivative(Real,bool)\n"
    "    SafeKrugerLogCubic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic_secondDerivative" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerLogCubic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeKrugerLogCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic_secondDerivative" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeKrugerLogCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerLogCubic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerLogCubic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerLogCubic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerLogCubic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerLogCubic::secondDerivative(Real,bool)\n"
    "    SafeKrugerLogCubic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic_primitive" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KrugerLogCubic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeKrugerLogCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogCubic_primitive" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KrugerLogCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeKrugerLogCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogCubic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "KrugerLogCubic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KrugerLogCubic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeKrugerLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KrugerLogCubic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'KrugerLogCubic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeKrugerLogCubic::primitive(Real,bool)\n"
    "    SafeKrugerLogCubic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_KrugerLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeKrugerLogCubic *arg1 = (SafeKrugerLogCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeKrugerLogCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KrugerLogCubic" "', argument " "1"" of type '" "SafeKrugerLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeKrugerLogCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KrugerLogCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeKrugerLogCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KrugerLogCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FritschButlandCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeFritschButlandCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FritschButlandCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FritschButlandCubic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FritschButlandCubic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FritschButlandCubic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FritschButlandCubic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeFritschButlandCubic *)new SafeFritschButlandCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeFritschButlandCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic___call__" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandCubic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic___call__" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandCubic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandCubic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandCubic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandCubic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandCubic::operator ()(Real,bool)\n"
    "    SafeFritschButlandCubic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic_derivative" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandCubic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeFritschButlandCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic_derivative" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeFritschButlandCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandCubic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandCubic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandCubic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandCubic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandCubic::derivative(Real,bool)\n"
    "    SafeFritschButlandCubic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic_secondDerivative" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandCubic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeFritschButlandCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic_secondDerivative" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeFritschButlandCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandCubic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandCubic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandCubic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandCubic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandCubic::secondDerivative(Real,bool)\n"
    "    SafeFritschButlandCubic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic_primitive" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandCubic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeFritschButlandCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandCubic_primitive" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeFritschButlandCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandCubic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandCubic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandCubic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandCubic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandCubic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandCubic::primitive(Real,bool)\n"
    "    SafeFritschButlandCubic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FritschButlandCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeFritschButlandCubic *arg1 = (SafeFritschButlandCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FritschButlandCubic" "', argument " "1"" of type '" "SafeFritschButlandCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FritschButlandCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeFritschButlandCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FritschButlandCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FritschButlandLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeFritschButlandLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FritschButlandLogCubic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FritschButlandLogCubic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FritschButlandLogCubic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FritschButlandLogCubic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FritschButlandLogCubic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeFritschButlandLogCubic *)new SafeFritschButlandLogCubic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeFritschButlandLogCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic___call__" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandLogCubic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic___call__" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandLogCubic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandLogCubic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandLogCubic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandLogCubic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandLogCubic::operator ()(Real,bool)\n"
    "    SafeFritschButlandLogCubic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic_derivative" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandLogCubic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic_derivative" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandLogCubic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandLogCubic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandLogCubic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandLogCubic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandLogCubic::derivative(Real,bool)\n"
    "    SafeFritschButlandLogCubic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic_secondDerivative" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandLogCubic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic_secondDerivative" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandLogCubic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandLogCubic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandLogCubic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandLogCubic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandLogCubic::secondDerivative(Real,bool)\n"
    "    SafeFritschButlandLogCubic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic_primitive" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FritschButlandLogCubic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FritschButlandLogCubic_primitive" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FritschButlandLogCubic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeFritschButlandLogCubic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FritschButlandLogCubic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FritschButlandLogCubic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FritschButlandLogCubic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeFritschButlandLogCubic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FritschButlandLogCubic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FritschButlandLogCubic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeFritschButlandLogCubic::primitive(Real,bool)\n"
    "    SafeFritschButlandLogCubic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FritschButlandLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeFritschButlandLogCubic *arg1 = (SafeFritschButlandLogCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeFritschButlandLogCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FritschButlandLogCubic" "', argument " "1"" of type '" "SafeFritschButlandLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SafeFritschButlandLogCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FritschButlandLogCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeFritschButlandLogCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FritschButlandLogCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Parabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Parabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Parabolic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Parabolic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Parabolic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Parabolic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeParabolic *)new SafeParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeParabolic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic___call__" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Parabolic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic___call__" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Parabolic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Parabolic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Parabolic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Parabolic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeParabolic::operator ()(Real,bool)\n"
    "    SafeParabolic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Parabolic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic_derivative" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Parabolic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic_derivative" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Parabolic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Parabolic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Parabolic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Parabolic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeParabolic::derivative(Real,bool)\n"
    "    SafeParabolic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Parabolic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic_secondDerivative" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Parabolic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic_secondDerivative" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Parabolic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Parabolic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Parabolic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Parabolic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeParabolic::secondDerivative(Real,bool)\n"
    "    SafeParabolic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Parabolic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic_primitive" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Parabolic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parabolic_primitive" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parabolic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Parabolic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Parabolic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Parabolic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Parabolic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeParabolic::primitive(Real,bool)\n"
    "    SafeParabolic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Parabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeParabolic *arg1 = (SafeParabolic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeParabolic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Parabolic" "', argument " "1"" of type '" "SafeParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeParabolic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Parabolic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeParabolic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Parabolic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogParabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeLogParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogParabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogParabolic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogParabolic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogParabolic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogParabolic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeLogParabolic *)new SafeLogParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeLogParabolic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic___call__" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogParabolic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic___call__" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogParabolic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogParabolic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogParabolic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogParabolic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogParabolic::operator ()(Real,bool)\n"
    "    SafeLogParabolic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogParabolic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic_derivative" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogParabolic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeLogParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic_derivative" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeLogParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogParabolic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogParabolic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogParabolic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogParabolic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogParabolic::derivative(Real,bool)\n"
    "    SafeLogParabolic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogParabolic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic_secondDerivative" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogParabolic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeLogParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic_secondDerivative" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeLogParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogParabolic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogParabolic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogParabolic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogParabolic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogParabolic::secondDerivative(Real,bool)\n"
    "    SafeLogParabolic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogParabolic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic_primitive" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogParabolic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeLogParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogParabolic_primitive" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogParabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeLogParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogParabolic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LogParabolic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogParabolic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogParabolic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LogParabolic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLogParabolic::primitive(Real,bool)\n"
    "    SafeLogParabolic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LogParabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeLogParabolic *arg1 = (SafeLogParabolic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLogParabolic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogParabolic" "', argument " "1"" of type '" "SafeLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeLogParabolic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogParabolic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeLogParabolic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogParabolic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicParabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicParabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicParabolic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicParabolic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicParabolic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicParabolic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeMonotonicParabolic *)new SafeMonotonicParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeMonotonicParabolic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic___call__" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicParabolic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic___call__" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicParabolic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicParabolic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicParabolic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicParabolic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicParabolic::operator ()(Real,bool)\n"
    "    SafeMonotonicParabolic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic_derivative" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicParabolic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic_derivative" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicParabolic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicParabolic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicParabolic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicParabolic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicParabolic::derivative(Real,bool)\n"
    "    SafeMonotonicParabolic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicParabolic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicParabolic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicParabolic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicParabolic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicParabolic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicParabolic::secondDerivative(Real,bool)\n"
    "    SafeMonotonicParabolic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic_primitive" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicParabolic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicParabolic_primitive" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicParabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicParabolic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicParabolic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicParabolic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicParabolic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicParabolic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicParabolic::primitive(Real,bool)\n"
    "    SafeMonotonicParabolic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicParabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeMonotonicParabolic *arg1 = (SafeMonotonicParabolic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicParabolic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicParabolic" "', argument " "1"" of type '" "SafeMonotonicParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicParabolic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicParabolic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeMonotonicParabolic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicParabolic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicLogParabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeMonotonicLogParabolic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicLogParabolic", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicLogParabolic" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogParabolic" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicLogParabolic" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogParabolic" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeMonotonicLogParabolic *)new SafeMonotonicLogParabolic((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeMonotonicLogParabolic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic___call__" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogParabolic___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic___call__" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogParabolic___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogParabolic___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogParabolic___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogParabolic___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogParabolic::operator ()(Real,bool)\n"
    "    SafeMonotonicLogParabolic::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_derivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic_derivative" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogParabolic_derivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_derivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_derivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic_derivative" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_derivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_derivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogParabolic_derivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogParabolic_derivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogParabolic_derivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogParabolic_derivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogParabolic::derivative(Real,bool)\n"
    "    SafeMonotonicLogParabolic::derivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_secondDerivative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogParabolic_secondDerivative" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_secondDerivative__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_secondDerivative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic_secondDerivative" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic_secondDerivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_secondDerivative__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_secondDerivative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogParabolic_secondDerivative", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogParabolic_secondDerivative__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogParabolic_secondDerivative__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogParabolic_secondDerivative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogParabolic::secondDerivative(Real,bool)\n"
    "    SafeMonotonicLogParabolic::secondDerivative(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_primitive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic_primitive" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MonotonicLogParabolic_primitive" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_primitive__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_primitive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogParabolic_primitive" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MonotonicLogParabolic_primitive" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)SafeMonotonicLogParabolic_primitive__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogParabolic_primitive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MonotonicLogParabolic_primitive", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MonotonicLogParabolic_primitive__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeMonotonicLogParabolic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MonotonicLogParabolic_primitive__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MonotonicLogParabolic_primitive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeMonotonicLogParabolic::primitive(Real,bool)\n"
    "    SafeMonotonicLogParabolic::primitive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicLogParabolic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeMonotonicLogParabolic *arg1 = (SafeMonotonicLogParabolic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeMonotonicLogParabolic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicLogParabolic" "', argument " "1"" of type '" "SafeMonotonicLogParabolic *""'"); 
  }
  arg1 = reinterpret_cast< SafeMonotonicLogParabolic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicLogParabolic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeMonotonicLogParabolic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicLogParabolic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LagrangeInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SafeLagrangeInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LagrangeInterpolation", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LagrangeInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LagrangeInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LagrangeInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LagrangeInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeLagrangeInterpolation *)new SafeLagrangeInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeLagrangeInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LagrangeInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLagrangeInterpolation *arg1 = (SafeLagrangeInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLagrangeInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagrangeInterpolation___call__" "', argument " "1"" of type '" "SafeLagrangeInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLagrangeInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LagrangeInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LagrangeInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LagrangeInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeLagrangeInterpolation *arg1 = (SafeLagrangeInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLagrangeInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagrangeInterpolation___call__" "', argument " "1"" of type '" "SafeLagrangeInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLagrangeInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LagrangeInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LagrangeInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LagrangeInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLagrangeInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LagrangeInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeLagrangeInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LagrangeInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LagrangeInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeLagrangeInterpolation::operator ()(Real,bool)\n"
    "    SafeLagrangeInterpolation::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LagrangeInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeLagrangeInterpolation *arg1 = (SafeLagrangeInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeLagrangeInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LagrangeInterpolation" "', argument " "1"" of type '" "SafeLagrangeInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeLagrangeInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LagrangeInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeLagrangeInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LagrangeInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BilinearInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Matrix temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SafeBilinearInterpolation *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BilinearInterpolation", 3, 3, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BilinearInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BilinearInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BilinearInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (PyTuple_Check(swig_obj[2]) || PyList_Check(swig_obj[2])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[2]) ?
      PyTuple_Size(swig_obj[2]) :
        PyList_Size(swig_obj[2]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[2],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp3 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[2],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp3[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp3[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BilinearInterpolation" "', argument " "3"" of type '" "Matrix const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BilinearInterpolation" "', argument " "3"" of type '" "Matrix const &""'"); 
      }
      arg3 = reinterpret_cast< Matrix * >(argp3);
    }
  }
  {
    try {
      result = (SafeBilinearInterpolation *)new SafeBilinearInterpolation((Array const &)*arg1,(Array const &)*arg2,(Matrix const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeBilinearInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BilinearInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeBilinearInterpolation *arg1 = (SafeBilinearInterpolation *) 0 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBilinearInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearInterpolation___call__" "', argument " "1"" of type '" "SafeBilinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeBilinearInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearInterpolation___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearInterpolation___call__" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BilinearInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeBilinearInterpolation *arg1 = (SafeBilinearInterpolation *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBilinearInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearInterpolation___call__" "', argument " "1"" of type '" "SafeBilinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeBilinearInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearInterpolation___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BilinearInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearInterpolation___call__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeBilinearInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BilinearInterpolation___call____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeBilinearInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BilinearInterpolation___call____SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeBilinearInterpolation::operator ()(Real,Real,bool)\n"
    "    SafeBilinearInterpolation::operator ()(Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BilinearInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeBilinearInterpolation *arg1 = (SafeBilinearInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBilinearInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearInterpolation" "', argument " "1"" of type '" "SafeBilinearInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeBilinearInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BilinearInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeBilinearInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BilinearInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BicubicSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Matrix temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  SafeBicubicSpline *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BicubicSpline", 3, 3, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BicubicSpline" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BicubicSpline" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BicubicSpline" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BicubicSpline" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (PyTuple_Check(swig_obj[2]) || PyList_Check(swig_obj[2])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[2]) ?
      PyTuple_Size(swig_obj[2]) :
        PyList_Size(swig_obj[2]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[2],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp3 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[2],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp3[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp3[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BicubicSpline" "', argument " "3"" of type '" "Matrix const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BicubicSpline" "', argument " "3"" of type '" "Matrix const &""'"); 
      }
      arg3 = reinterpret_cast< Matrix * >(argp3);
    }
  }
  {
    try {
      result = (SafeBicubicSpline *)new SafeBicubicSpline((Array const &)*arg1,(Array const &)*arg2,(Matrix const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeBicubicSpline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BicubicSpline___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeBicubicSpline *arg1 = (SafeBicubicSpline *) 0 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBicubicSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BicubicSpline___call__" "', argument " "1"" of type '" "SafeBicubicSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeBicubicSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BicubicSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BicubicSpline___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BicubicSpline___call__" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BicubicSpline___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeBicubicSpline *arg1 = (SafeBicubicSpline *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBicubicSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BicubicSpline___call__" "', argument " "1"" of type '" "SafeBicubicSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeBicubicSpline * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BicubicSpline___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BicubicSpline___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BicubicSpline___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BicubicSpline___call__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeBicubicSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BicubicSpline___call____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeBicubicSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BicubicSpline___call____SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BicubicSpline___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeBicubicSpline::operator ()(Real,Real,bool)\n"
    "    SafeBicubicSpline::operator ()(Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BicubicSpline(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeBicubicSpline *arg1 = (SafeBicubicSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeBicubicSpline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BicubicSpline" "', argument " "1"" of type '" "SafeBicubicSpline *""'"); 
  }
  arg1 = reinterpret_cast< SafeBicubicSpline * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BicubicSpline_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeBicubicSpline, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BicubicSpline_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_CubicInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CubicInterpolation *arg1 = (CubicInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CubicInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CubicInterpolation" "', argument " "1"" of type '" "CubicInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< CubicInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CubicInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CubicInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_MixedInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MixedInterpolation *arg1 = (MixedInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MixedInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedInterpolation" "', argument " "1"" of type '" "MixedInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< MixedInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MixedInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MixedInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BackwardFlat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BackwardFlat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BackwardFlat", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (BackwardFlat *)new BackwardFlat();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BackwardFlat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BackwardFlat *arg1 = (BackwardFlat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BackwardFlat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackwardFlat" "', argument " "1"" of type '" "BackwardFlat *""'"); 
  }
  arg1 = reinterpret_cast< BackwardFlat * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BackwardFlat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BackwardFlat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BackwardFlat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardFlat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardFlat *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ForwardFlat", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ForwardFlat *)new ForwardFlat();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ForwardFlat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardFlat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardFlat *arg1 = (ForwardFlat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ForwardFlat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardFlat" "', argument " "1"" of type '" "ForwardFlat *""'"); 
  }
  arg1 = reinterpret_cast< ForwardFlat * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardFlat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ForwardFlat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardFlat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Linear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Linear *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Linear", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Linear *)new Linear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Linear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Linear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Linear *arg1 = (Linear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Linear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Linear" "', argument " "1"" of type '" "Linear *""'"); 
  }
  arg1 = reinterpret_cast< Linear * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Linear_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Linear, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Linear_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogLinear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogLinear *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LogLinear", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (LogLinear *)new LogLinear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LogLinear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LogLinear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogLinear *arg1 = (LogLinear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LogLinear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogLinear" "', argument " "1"" of type '" "LogLinear *""'"); 
  }
  arg1 = reinterpret_cast< LogLinear * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogLinear_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LogLinear, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogLinear_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Cubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Cubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Cubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Cubic *)new Cubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Cubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Cubic *arg1 = (Cubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Cubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cubic" "', argument " "1"" of type '" "Cubic *""'"); 
  }
  arg1 = reinterpret_cast< Cubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Cubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Cubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Cubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bicubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bicubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Bicubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Bicubic *)new Bicubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Bicubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Bicubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bicubic *arg1 = (Bicubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Bicubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bicubic" "', argument " "1"" of type '" "Bicubic *""'"); 
  }
  arg1 = reinterpret_cast< Bicubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bicubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Bicubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bicubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MonotonicCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicCubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (MonotonicCubic *)new MonotonicCubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MonotonicCubic *arg1 = (MonotonicCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicCubic" "', argument " "1"" of type '" "MonotonicCubic *""'"); 
  }
  arg1 = reinterpret_cast< MonotonicCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MonotonicCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DefaultLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DefaultLogCubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (DefaultLogCubic *)new DefaultLogCubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DefaultLogCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefaultLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultLogCubic *arg1 = (DefaultLogCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultLogCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultLogCubic" "', argument " "1"" of type '" "DefaultLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< DefaultLogCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultLogCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DefaultLogCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DefaultLogCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MonotonicLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MonotonicLogCubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (MonotonicLogCubic *)new MonotonicLogCubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MonotonicLogCubic *arg1 = (MonotonicLogCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicLogCubic" "', argument " "1"" of type '" "MonotonicLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< MonotonicLogCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicLogCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MonotonicLogCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicLogCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SplineCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SplineCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SplineCubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (SplineCubic *)new SplineCubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SplineCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SplineCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SplineCubic *arg1 = (SplineCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SplineCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplineCubic" "', argument " "1"" of type '" "SplineCubic *""'"); 
  }
  arg1 = reinterpret_cast< SplineCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SplineCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SplineCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SplineCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SplineLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SplineLogCubic *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SplineLogCubic", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (SplineLogCubic *)new SplineLogCubic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SplineLogCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SplineLogCubic *arg1 = (SplineLogCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplineLogCubic" "', argument " "1"" of type '" "SplineLogCubic *""'"); 
  }
  arg1 = reinterpret_cast< SplineLogCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SplineLogCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SplineLogCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SplineLogCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Kruger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Kruger *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Kruger", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Kruger *)new Kruger();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Kruger, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Kruger(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Kruger *arg1 = (Kruger *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Kruger, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Kruger" "', argument " "1"" of type '" "Kruger *""'"); 
  }
  arg1 = reinterpret_cast< Kruger * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Kruger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Kruger, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Kruger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KrugerLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KrugerLog *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KrugerLog", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (KrugerLog *)new KrugerLog();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KrugerLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KrugerLog(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KrugerLog *arg1 = (KrugerLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KrugerLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KrugerLog" "', argument " "1"" of type '" "KrugerLog *""'"); 
  }
  arg1 = reinterpret_cast< KrugerLog * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KrugerLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_KrugerLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KrugerLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConvexMonotone__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  bool arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  ConvexMonotone *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConvexMonotone" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvexMonotone" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConvexMonotone" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotone__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  ConvexMonotone *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConvexMonotone" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvexMonotone" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotone__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  ConvexMonotone *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConvexMonotone" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotone__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ConvexMonotone *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ConvexMonotone *)new ConvexMonotone();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotone(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvexMonotone", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ConvexMonotone__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ConvexMonotone__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ConvexMonotone__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ConvexMonotone__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvexMonotone'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConvexMonotone::ConvexMonotone(Real,Real,bool)\n"
    "    ConvexMonotone::ConvexMonotone(Real,Real)\n"
    "    ConvexMonotone::ConvexMonotone(Real)\n"
    "    ConvexMonotone::ConvexMonotone()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvexMonotone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConvexMonotone *arg1 = (ConvexMonotone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvexMonotone" "', argument " "1"" of type '" "ConvexMonotone *""'"); 
  }
  arg1 = reinterpret_cast< ConvexMonotone * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConvexMonotone_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ConvexMonotone, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConvexMonotone_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogMixedLinearCubic(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Size arg1 = (Size) 0 ;
  MixedInterpolation::Behavior arg2 = (MixedInterpolation::Behavior) MixedInterpolation::ShareRanges ;
  CubicInterpolation::DerivativeApprox arg3 = (CubicInterpolation::DerivativeApprox) CubicInterpolation::Spline ;
  bool arg4 = (bool) true ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"n",  (char *)"behavior",  (char *)"da",  (char *)"monotonic",  NULL 
  };
  LogMixedLinearCubic *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:new_LogMixedLinearCubic", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_size_t(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LogMixedLinearCubic" "', argument " "1"" of type '" "Size""'");
    } 
    arg1 = static_cast< Size >(val1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LogMixedLinearCubic" "', argument " "2"" of type '" "MixedInterpolation::Behavior""'");
    } 
    arg2 = static_cast< MixedInterpolation::Behavior >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogMixedLinearCubic" "', argument " "3"" of type '" "CubicInterpolation::DerivativeApprox""'");
    } 
    arg3 = static_cast< CubicInterpolation::DerivativeApprox >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogMixedLinearCubic" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  {
    try {
      result = (LogMixedLinearCubic *)new LogMixedLinearCubic(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LogMixedLinearCubic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogMixedLinearCubic *arg1 = (LogMixedLinearCubic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogMixedLinearCubic" "', argument " "1"" of type '" "LogMixedLinearCubic *""'"); 
  }
  arg1 = reinterpret_cast< LogMixedLinearCubic * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogMixedLinearCubic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LogMixedLinearCubic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogMixedLinearCubic_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SABRInterpolation(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  bool arg9 = (bool) false ;
  bool arg10 = (bool) false ;
  bool arg11 = (bool) false ;
  bool arg12 = (bool) false ;
  bool arg13 = (bool) true ;
  ext::shared_ptr< EndCriteria > const &arg14_defvalue = ext::shared_ptr< EndCriteria >() ;
  ext::shared_ptr< EndCriteria > *arg14 = (ext::shared_ptr< EndCriteria > *) &arg14_defvalue ;
  ext::shared_ptr< OptimizationMethod > const &arg15_defvalue = ext::shared_ptr< OptimizationMethod >() ;
  ext::shared_ptr< OptimizationMethod > *arg15 = (ext::shared_ptr< OptimizationMethod > *) &arg15_defvalue ;
  Real arg16 = (Real) (Real)0.0020 ;
  bool arg17 = (bool) (bool)false ;
  Size arg18 = (Size) (Size)50 ;
  Real arg19 = (Real) (Real)0.0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  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 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared14 ;
  void *argp15 ;
  int res15 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared15 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  size_t val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  char * kwnames[] = {
    (char *)"x",  (char *)"y",  (char *)"t",  (char *)"forward",  (char *)"alpha",  (char *)"beta",  (char *)"nu",  (char *)"rho",  (char *)"alphaIsFixed",  (char *)"betaIsFixed",  (char *)"nuIsFixed",  (char *)"rhoIsFixed",  (char *)"vegaWeighted",  (char *)"endCriteria",  (char *)"optMethod",  (char *)"errorAccept",  (char *)"useMaxError",  (char *)"maxGuesses",  (char *)"shift",  NULL 
  };
  SafeSABRInterpolation *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO|OOOOOOOOOOO:new_SABRInterpolation", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18)) SWIG_fail;
  {
    if (ArrayFromSequence(obj0,&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SABRInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SABRInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(obj1,&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SABRInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SABRInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SABRInterpolation" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SABRInterpolation" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SABRInterpolation" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SABRInterpolation" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SABRInterpolation" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SABRInterpolation" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SABRInterpolation" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_bool(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SABRInterpolation" "', argument " "10"" of type '" "bool""'");
    } 
    arg10 = static_cast< bool >(val10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_bool(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SABRInterpolation" "', argument " "11"" of type '" "bool""'");
    } 
    arg11 = static_cast< bool >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SABRInterpolation" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_bool(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SABRInterpolation" "', argument " "13"" of type '" "bool""'");
    } 
    arg13 = static_cast< bool >(val13);
  }
  if (obj13) {
    {
      int newmem = 0;
      res14 = SWIG_ConvertPtrAndOwn(obj13, &argp14, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
      if (!SWIG_IsOK(res14)) {
        SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SABRInterpolation" "', argument " "14"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp14);
        delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp14);
        arg14 = &tempshared14;
      } else {
        arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp14) : &tempshared14;
      }
    }
  }
  if (obj14) {
    {
      int newmem = 0;
      res15 = SWIG_ConvertPtrAndOwn(obj14, &argp15, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
      if (!SWIG_IsOK(res15)) {
        SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_SABRInterpolation" "', argument " "15"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp15) tempshared15 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp15);
        delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp15);
        arg15 = &tempshared15;
      } else {
        arg15 = (argp15) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp15) : &tempshared15;
      }
    }
  }
  if (obj15) {
    ecode16 = SWIG_AsVal_double(obj15, &val16);
    if (!SWIG_IsOK(ecode16)) {
      SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SABRInterpolation" "', argument " "16"" of type '" "Real""'");
    } 
    arg16 = static_cast< Real >(val16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_bool(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SABRInterpolation" "', argument " "17"" of type '" "bool""'");
    } 
    arg17 = static_cast< bool >(val17);
  }
  if (obj17) {
    ecode18 = SWIG_AsVal_size_t(obj17, &val18);
    if (!SWIG_IsOK(ecode18)) {
      SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_SABRInterpolation" "', argument " "18"" of type '" "Size""'");
    } 
    arg18 = static_cast< Size >(val18);
  }
  if (obj18) {
    ecode19 = SWIG_AsVal_double(obj18, &val19);
    if (!SWIG_IsOK(ecode19)) {
      SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_SABRInterpolation" "', argument " "19"" of type '" "Real""'");
    } 
    arg19 = static_cast< Real >(val19);
  }
  {
    try {
      result = (SafeSABRInterpolation *)new SafeSABRInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(ext::shared_ptr< EndCriteria > const &)*arg14,(ext::shared_ptr< OptimizationMethod > const &)*arg15,arg16,arg17,arg18,arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeSABRInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SABRInterpolation___call__" "', argument " "1"" of type '" "SafeSABRInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SABRInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SABRInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SABRInterpolation___call__" "', argument " "1"" of type '" "SafeSABRInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SABRInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SABRInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeSABRInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SABRInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeSABRInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SABRInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SABRInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeSABRInterpolation::operator ()(Real,bool) const\n"
    "    SafeSABRInterpolation::operator ()(Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SABRInterpolation_alpha" "', argument " "1"" of type '" "SafeSABRInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SABRInterpolation_beta" "', argument " "1"" of type '" "SafeSABRInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SABRInterpolation_rho" "', argument " "1"" of type '" "SafeSABRInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SABRInterpolation_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SABRInterpolation_nu" "', argument " "1"" of type '" "SafeSABRInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  {
    try {
      result = (Real)((SafeSABRInterpolation const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SABRInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeSABRInterpolation *arg1 = (SafeSABRInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeSABRInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SABRInterpolation" "', argument " "1"" of type '" "SafeSABRInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeSABRInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SABRInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeSABRInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SABRInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RichardsonExtrapolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RichardsonExtrapolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichardsonExtrapolation___call__" "', argument " "1"" of type '" "RichardsonExtrapolation const *""'"); 
  }
  arg1 = reinterpret_cast< RichardsonExtrapolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichardsonExtrapolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RichardsonExtrapolation const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RichardsonExtrapolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RichardsonExtrapolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichardsonExtrapolation___call__" "', argument " "1"" of type '" "RichardsonExtrapolation const *""'"); 
  }
  arg1 = reinterpret_cast< RichardsonExtrapolation * >(argp1);
  {
    try {
      result = (Real)((RichardsonExtrapolation const *)arg1)->operator ()();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RichardsonExtrapolation___call____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RichardsonExtrapolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichardsonExtrapolation___call__" "', argument " "1"" of type '" "RichardsonExtrapolation const *""'"); 
  }
  arg1 = reinterpret_cast< RichardsonExtrapolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichardsonExtrapolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichardsonExtrapolation___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((RichardsonExtrapolation const *)arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RichardsonExtrapolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RichardsonExtrapolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_RichardsonExtrapolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RichardsonExtrapolation___call____SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_RichardsonExtrapolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RichardsonExtrapolation___call____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_RichardsonExtrapolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RichardsonExtrapolation___call____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RichardsonExtrapolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RichardsonExtrapolation::operator ()(Real) const\n"
    "    RichardsonExtrapolation::operator ()() const\n"
    "    RichardsonExtrapolation::operator ()(Real,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_RichardsonExtrapolation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Real arg2 ;
  Real arg3 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  RichardsonExtrapolation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RichardsonExtrapolation" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RichardsonExtrapolation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (RichardsonExtrapolation *)new_RichardsonExtrapolation__SWIG_0(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RichardsonExtrapolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RichardsonExtrapolation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  Real arg2 ;
  double val2 ;
  int ecode2 = 0 ;
  RichardsonExtrapolation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  arg1 = swig_obj[0];
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RichardsonExtrapolation" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (RichardsonExtrapolation *)new_RichardsonExtrapolation__SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RichardsonExtrapolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RichardsonExtrapolation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RichardsonExtrapolation", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    _v = (argv[0] != 0);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RichardsonExtrapolation__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    _v = (argv[0] != 0);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RichardsonExtrapolation__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RichardsonExtrapolation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RichardsonExtrapolation::RichardsonExtrapolation(PyObject *,Real,Real)\n"
    "    RichardsonExtrapolation::RichardsonExtrapolation(PyObject *,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RichardsonExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RichardsonExtrapolation *arg1 = (RichardsonExtrapolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RichardsonExtrapolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichardsonExtrapolation" "', argument " "1"" of type '" "RichardsonExtrapolation *""'"); 
  }
  arg1 = reinterpret_cast< RichardsonExtrapolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RichardsonExtrapolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RichardsonExtrapolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RichardsonExtrapolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ChebyshevInterpolation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  ChebyshevInterpolation::PointsType arg2 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ChebyshevInterpolation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChebyshevInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChebyshevInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChebyshevInterpolation" "', argument " "2"" of type '" "ChebyshevInterpolation::PointsType""'");
  } 
  arg2 = static_cast< ChebyshevInterpolation::PointsType >(val2);
  {
    try {
      result = (ChebyshevInterpolation *)new ChebyshevInterpolation((Array const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChebyshevInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChebyshevInterpolation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ChebyshevInterpolation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChebyshevInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChebyshevInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    try {
      result = (ChebyshevInterpolation *)new ChebyshevInterpolation((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChebyshevInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChebyshevInterpolation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  PyObject *arg2 = (PyObject *) 0 ;
  ChebyshevInterpolation::PointsType arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  ChebyshevInterpolation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChebyshevInterpolation" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChebyshevInterpolation" "', argument " "3"" of type '" "ChebyshevInterpolation::PointsType""'");
  } 
  arg3 = static_cast< ChebyshevInterpolation::PointsType >(val3);
  {
    try {
      result = (ChebyshevInterpolation *)new_ChebyshevInterpolation__SWIG_2(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChebyshevInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChebyshevInterpolation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  PyObject *arg2 = (PyObject *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  ChebyshevInterpolation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ChebyshevInterpolation" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  arg2 = swig_obj[1];
  {
    try {
      result = (ChebyshevInterpolation *)new_ChebyshevInterpolation__SWIG_2(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChebyshevInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChebyshevInterpolation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ChebyshevInterpolation", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      return _wrap_new_ChebyshevInterpolation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_new_ChebyshevInterpolation__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ChebyshevInterpolation__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ChebyshevInterpolation__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ChebyshevInterpolation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ChebyshevInterpolation::ChebyshevInterpolation(Array const &,ChebyshevInterpolation::PointsType)\n"
    "    ChebyshevInterpolation::ChebyshevInterpolation(Array const &)\n"
    "    ChebyshevInterpolation::ChebyshevInterpolation(Size,PyObject *,ChebyshevInterpolation::PointsType)\n"
    "    ChebyshevInterpolation::ChebyshevInterpolation(Size,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChebyshevInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ChebyshevInterpolation *arg1 = (ChebyshevInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ChebyshevInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevInterpolation___call__" "', argument " "1"" of type '" "ChebyshevInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< ChebyshevInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChebyshevInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ChebyshevInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)((ChebyshevInterpolation const *)arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChebyshevInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ChebyshevInterpolation *arg1 = (ChebyshevInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ChebyshevInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevInterpolation___call__" "', argument " "1"" of type '" "ChebyshevInterpolation const *""'"); 
  }
  arg1 = reinterpret_cast< ChebyshevInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChebyshevInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((ChebyshevInterpolation const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ChebyshevInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ChebyshevInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ChebyshevInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ChebyshevInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ChebyshevInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ChebyshevInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ChebyshevInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ChebyshevInterpolation::operator ()(Real,bool) const\n"
    "    ChebyshevInterpolation::operator ()(Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ChebyshevInterpolation_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ChebyshevInterpolation::PointsType arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "ChebyshevInterpolation_nodes", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ChebyshevInterpolation_nodes" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ChebyshevInterpolation_nodes" "', argument " "2"" of type '" "ChebyshevInterpolation::PointsType""'");
  } 
  arg2 = static_cast< ChebyshevInterpolation::PointsType >(val2);
  {
    try {
      result = ChebyshevInterpolation::nodes(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ChebyshevInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ChebyshevInterpolation *arg1 = (ChebyshevInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ChebyshevInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChebyshevInterpolation" "', argument " "1"" of type '" "ChebyshevInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< ChebyshevInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ChebyshevInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ChebyshevInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ChebyshevInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConvexMonotoneInterpolation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  bool arg5 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeConvexMonotoneInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotoneInterpolation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeConvexMonotoneInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotoneInterpolation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((Array const &)*arg1,(Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeConvexMonotoneInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotoneInterpolation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SafeConvexMonotoneInterpolation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvexMonotoneInterpolation" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (SafeConvexMonotoneInterpolation *)new SafeConvexMonotoneInterpolation((Array const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SafeConvexMonotoneInterpolation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvexMonotoneInterpolation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvexMonotoneInterpolation", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_new_ConvexMonotoneInterpolation__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ConvexMonotoneInterpolation__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ConvexMonotoneInterpolation__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ConvexMonotoneInterpolation__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvexMonotoneInterpolation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeConvexMonotoneInterpolation::SafeConvexMonotoneInterpolation(Array const &,Array const &,Real,Real,bool)\n"
    "    SafeConvexMonotoneInterpolation::SafeConvexMonotoneInterpolation(Array const &,Array const &,Real,Real)\n"
    "    SafeConvexMonotoneInterpolation::SafeConvexMonotoneInterpolation(Array const &,Array const &,Real)\n"
    "    SafeConvexMonotoneInterpolation::SafeConvexMonotoneInterpolation(Array const &,Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConvexMonotoneInterpolation___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeConvexMonotoneInterpolation *arg1 = (SafeConvexMonotoneInterpolation *) 0 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeConvexMonotoneInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexMonotoneInterpolation___call__" "', argument " "1"" of type '" "SafeConvexMonotoneInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeConvexMonotoneInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvexMonotoneInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConvexMonotoneInterpolation___call__" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConvexMonotoneInterpolation___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SafeConvexMonotoneInterpolation *arg1 = (SafeConvexMonotoneInterpolation *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeConvexMonotoneInterpolation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexMonotoneInterpolation___call__" "', argument " "1"" of type '" "SafeConvexMonotoneInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeConvexMonotoneInterpolation * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvexMonotoneInterpolation___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConvexMonotoneInterpolation___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConvexMonotoneInterpolation___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeConvexMonotoneInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConvexMonotoneInterpolation___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SafeConvexMonotoneInterpolation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConvexMonotoneInterpolation___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConvexMonotoneInterpolation___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SafeConvexMonotoneInterpolation::operator ()(Real,bool)\n"
    "    SafeConvexMonotoneInterpolation::operator ()(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvexMonotoneInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SafeConvexMonotoneInterpolation *arg1 = (SafeConvexMonotoneInterpolation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SafeConvexMonotoneInterpolation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvexMonotoneInterpolation" "', argument " "1"" of type '" "SafeConvexMonotoneInterpolation *""'"); 
  }
  arg1 = reinterpret_cast< SafeConvexMonotoneInterpolation * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConvexMonotoneInterpolation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SafeConvexMonotoneInterpolation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConvexMonotoneInterpolation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_TermStructure_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure const > tempshared1 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_dayCounter" "', argument " "1"" of type '" "TermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((TermStructure const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure const > tempshared1 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "TermStructure_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_timeFromReference" "', argument " "1"" of type '" "TermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TermStructure_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TermStructure_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)((TermStructure const *)arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure const > tempshared1 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_calendar" "', argument " "1"" of type '" "TermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((TermStructure const *)arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure const > tempshared1 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_referenceDate" "', argument " "1"" of type '" "TermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((TermStructure const *)arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure const > tempshared1 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_maxDate" "', argument " "1"" of type '" "TermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((TermStructure const *)arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure const > tempshared1 ;
  ext::shared_ptr< TermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_maxTime" "', argument " "1"" of type '" "TermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Time)((TermStructure const *)arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure > tempshared1 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_enableExtrapolation" "', argument " "1"" of type '" "TermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure > tempshared1 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_disableExtrapolation" "', argument " "1"" of type '" "TermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TermStructure_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure > tempshared1 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructure_allowsExtrapolation" "', argument " "1"" of type '" "TermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)(arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructure *arg1 = (TermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructure > tempshared1 ;
  ext::shared_ptr< TermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TermStructure" "', argument " "1"" of type '" "TermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TermStructure > * >(argp1);
      arg1 = const_cast< TermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_YieldTermStructure_discount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_discount" "', argument " "1"" of type '" "YieldTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_discount" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (DiscountFactor)(arg1)->discount((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_discount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_discount" "', argument " "1"" of type '" "YieldTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (DiscountFactor)(arg1)->discount((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_discount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_discount" "', argument " "1"" of type '" "YieldTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_discount" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (DiscountFactor)(arg1)->discount(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_discount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_discount" "', argument " "1"" of type '" "YieldTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (DiscountFactor)(arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_discount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YieldTermStructure_discount", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YieldTermStructure_discount__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YieldTermStructure_discount__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YieldTermStructure_discount__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YieldTermStructure_discount__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YieldTermStructure_discount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YieldTermStructure::discount(Date const &,bool)\n"
    "    YieldTermStructure::discount(Date const &)\n"
    "    YieldTermStructure::discount(Time,bool)\n"
    "    YieldTermStructure::discount(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_zeroRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_zeroRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_zeroRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructure_zeroRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_zeroRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_zeroRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_zeroRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_zeroRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_zeroRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_zeroRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_zeroRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_zeroRate" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->zeroRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_zeroRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_zeroRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->zeroRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  InterestRate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_zeroRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_zeroRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->zeroRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_zeroRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YieldTermStructure_zeroRate", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YieldTermStructure_zeroRate__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YieldTermStructure_zeroRate__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YieldTermStructure_zeroRate__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructure_zeroRate__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructure_zeroRate__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YieldTermStructure_zeroRate__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YieldTermStructure_zeroRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YieldTermStructure::zeroRate(Date const &,DayCounter const &,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::zeroRate(Date const &,DayCounter const &,Compounding,Frequency) const\n"
    "    YieldTermStructure::zeroRate(Date const &,DayCounter const &,Compounding) const\n"
    "    YieldTermStructure::zeroRate(Time,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::zeroRate(Time,Compounding,Frequency) const\n"
    "    YieldTermStructure::zeroRate(Time,Compounding) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  InterestRate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_forwardRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_forwardRate" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructure_forwardRate" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "YieldTermStructure_forwardRate" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_forwardRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_forwardRate" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructure_forwardRate" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_forwardRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_forwardRate" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_forwardRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_forwardRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructure_forwardRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->forwardRate(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_forwardRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructure_forwardRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->forwardRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared1 ;
  ext::shared_ptr< YieldTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructure_forwardRate" "', argument " "1"" of type '" "YieldTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructure_forwardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructure_forwardRate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructure_forwardRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = ((YieldTermStructure const *)arg1)->forwardRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructure_forwardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YieldTermStructure_forwardRate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YieldTermStructure_forwardRate__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructure_forwardRate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructure_forwardRate__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YieldTermStructure_forwardRate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YieldTermStructure_forwardRate__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_YieldTermStructure_forwardRate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YieldTermStructure_forwardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YieldTermStructure::forwardRate(Date const &,Date const &,DayCounter const &,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::forwardRate(Date const &,Date const &,DayCounter const &,Compounding,Frequency) const\n"
    "    YieldTermStructure::forwardRate(Date const &,Date const &,DayCounter const &,Compounding) const\n"
    "    YieldTermStructure::forwardRate(Time,Time,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::forwardRate(Time,Time,Compounding,Frequency) const\n"
    "    YieldTermStructure::forwardRate(Time,Time,Compounding) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YieldTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YieldTermStructure *arg1 = (YieldTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  ext::shared_ptr< YieldTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldTermStructure" "', argument " "1"" of type '" "YieldTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YieldTermStructure > * >(argp1);
      arg1 = const_cast< YieldTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YieldTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YieldTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YieldTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *)new Handle< YieldTermStructure >((ext::shared_ptr< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< YieldTermStructure > *)new Handle< YieldTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YieldTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_YieldTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YieldTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< YieldTermStructure >::Handle(ext::shared_ptr< YieldTermStructure > const &)\n"
    "    Handle< YieldTermStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle___deref__" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YieldTermStructure > *smartresult = result ? new ext::shared_ptr<  YieldTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YieldTermStructure > *smartresult = result ? new ext::shared_ptr<  YieldTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_YieldTermStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle___bool__" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_YieldTermStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_YieldTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YieldTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldTermStructureHandle" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_discount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_discount" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_discount" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (DiscountFactor)(*arg1)->discount((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_discount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_discount" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_discount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (DiscountFactor)(*arg1)->discount((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_discount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_discount" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_discount" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (DiscountFactor)(*arg1)->discount(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_discount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  DiscountFactor result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_discount" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (DiscountFactor)(*arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_discount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YieldTermStructureHandle_discount", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YieldTermStructureHandle_discount__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YieldTermStructureHandle_discount__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YieldTermStructureHandle_discount__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YieldTermStructureHandle_discount__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YieldTermStructureHandle_discount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YieldTermStructure::discount(Date const &,bool)\n"
    "    YieldTermStructure::discount(Date const &)\n"
    "    YieldTermStructure::discount(Time,bool)\n"
    "    YieldTermStructure::discount(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (*arg1)->zeroRate((Date const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  Frequency arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Compounding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  InterestRate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  {
    try {
      result = (*arg1)->zeroRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_zeroRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YieldTermStructureHandle_zeroRate", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YieldTermStructureHandle_zeroRate__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YieldTermStructureHandle_zeroRate__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YieldTermStructureHandle_zeroRate__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructureHandle_zeroRate__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructureHandle_zeroRate__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YieldTermStructureHandle_zeroRate__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YieldTermStructureHandle_zeroRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YieldTermStructure::zeroRate(Date const &,DayCounter const &,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::zeroRate(Date const &,DayCounter const &,Compounding,Frequency) const\n"
    "    YieldTermStructure::zeroRate(Date const &,DayCounter const &,Compounding) const\n"
    "    YieldTermStructure::zeroRate(Time,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::zeroRate(Time,Compounding,Frequency) const\n"
    "    YieldTermStructure::zeroRate(Time,Compounding) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  InterestRate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  {
    try {
      result = (*arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  InterestRate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  InterestRate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  InterestRate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YieldTermStructureHandle_forwardRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (*arg1)->forwardRate(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_forwardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YieldTermStructureHandle_forwardRate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YieldTermStructureHandle_forwardRate__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructureHandle_forwardRate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YieldTermStructureHandle_forwardRate__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YieldTermStructureHandle_forwardRate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YieldTermStructureHandle_forwardRate__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_YieldTermStructureHandle_forwardRate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YieldTermStructureHandle_forwardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YieldTermStructure::forwardRate(Date const &,Date const &,DayCounter const &,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::forwardRate(Date const &,Date const &,DayCounter const &,Compounding,Frequency) const\n"
    "    YieldTermStructure::forwardRate(Date const &,Date const &,DayCounter const &,Compounding) const\n"
    "    YieldTermStructure::forwardRate(Time,Time,Compounding,Frequency,bool) const\n"
    "    YieldTermStructure::forwardRate(Time,Time,Compounding,Frequency) const\n"
    "    YieldTermStructure::forwardRate(Time,Time,Compounding) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "YieldTermStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YieldTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YieldTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_calendar" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< YieldTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YieldTermStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = (Handle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YieldTermStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YieldTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YieldTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableYieldTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  RelinkableHandle< YieldTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableYieldTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< YieldTermStructure > *)new RelinkableHandle< YieldTermStructure >((ext::shared_ptr< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableYieldTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< YieldTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< YieldTermStructure > *)new RelinkableHandle< YieldTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableYieldTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableYieldTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableYieldTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableYieldTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableYieldTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< YieldTermStructure >::RelinkableHandle(ext::shared_ptr< YieldTermStructure > const &)\n"
    "    RelinkableHandle< YieldTermStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableYieldTermStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YieldTermStructure > *arg1 = (RelinkableHandle< YieldTermStructure > *) 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableYieldTermStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableYieldTermStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YieldTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableYieldTermStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableYieldTermStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YieldTermStructure > *arg1 = (RelinkableHandle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableYieldTermStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YieldTermStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_YieldTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableYieldTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YieldTermStructure > *arg1 = (RelinkableHandle< YieldTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableYieldTermStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< YieldTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YieldTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableYieldTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_YieldTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableYieldTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImpliedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ImpliedTermStructure *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ImpliedTermStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImpliedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImpliedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImpliedTermStructure" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImpliedTermStructure" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (ImpliedTermStructure *)new ImpliedTermStructure((Handle< YieldTermStructure > const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ImpliedTermStructure > *smartresult = result ? new ext::shared_ptr<  ImpliedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ImpliedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ImpliedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ImpliedTermStructure *arg1 = (ImpliedTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ImpliedTermStructure > tempshared1 ;
  ext::shared_ptr< ImpliedTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ImpliedTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImpliedTermStructure" "', argument " "1"" of type '" "ImpliedTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ImpliedTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ImpliedTermStructure > * >(argp1);
      arg1 = const_cast< ImpliedTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ImpliedTermStructure > * >(argp1);
      arg1 = const_cast< ImpliedTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ImpliedTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ImpliedTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImpliedTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZeroSpreadedTermStructure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroSpreadedTermStructure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroSpreadedTermStructure__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Compounding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroSpreadedTermStructure__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (ZeroSpreadedTermStructure *)new ZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  ZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroSpreadedTermStructure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroSpreadedTermStructure", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ZeroSpreadedTermStructure__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ZeroSpreadedTermStructure__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ZeroSpreadedTermStructure__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ZeroSpreadedTermStructure__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroSpreadedTermStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroSpreadedTermStructure::ZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,Handle< Quote > const &,Compounding,Frequency,DayCounter const &)\n"
    "    ZeroSpreadedTermStructure::ZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,Handle< Quote > const &,Compounding,Frequency)\n"
    "    ZeroSpreadedTermStructure::ZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,Handle< Quote > const &,Compounding)\n"
    "    ZeroSpreadedTermStructure::ZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZeroSpreadedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroSpreadedTermStructure *arg1 = (ZeroSpreadedTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroSpreadedTermStructure > tempshared1 ;
  ext::shared_ptr< ZeroSpreadedTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroSpreadedTermStructure" "', argument " "1"" of type '" "ZeroSpreadedTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroSpreadedTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroSpreadedTermStructure > * >(argp1);
      arg1 = const_cast< ZeroSpreadedTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroSpreadedTermStructure > * >(argp1);
      arg1 = const_cast< ZeroSpreadedTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroSpreadedTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroSpreadedTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroSpreadedTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardSpreadedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ForwardSpreadedTermStructure *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ForwardSpreadedTermStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardSpreadedTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (ForwardSpreadedTermStructure *)new ForwardSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  ForwardSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardSpreadedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardSpreadedTermStructure *arg1 = (ForwardSpreadedTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardSpreadedTermStructure > tempshared1 ;
  ext::shared_ptr< ForwardSpreadedTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardSpreadedTermStructure" "', argument " "1"" of type '" "ForwardSpreadedTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ForwardSpreadedTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ForwardSpreadedTermStructure > * >(argp1);
      arg1 = const_cast< ForwardSpreadedTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ForwardSpreadedTermStructure > * >(argp1);
      arg1 = const_cast< ForwardSpreadedTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardSpreadedTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ForwardSpreadedTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardSpreadedTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  Linear *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  arg7 = reinterpret_cast< Linear * >(argp7);
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PiecewiseZeroSpreadedTermStructure *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroSpreadedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (PiecewiseZeroSpreadedTermStructure *)new PiecewiseZeroSpreadedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroSpreadedTermStructure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseZeroSpreadedTermStructure", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseZeroSpreadedTermStructure__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseZeroSpreadedTermStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseZeroSpreadedTermStructure::PiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &,Linear const &)\n"
    "    PiecewiseZeroSpreadedTermStructure::PiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &)\n"
    "    PiecewiseZeroSpreadedTermStructure::PiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency)\n"
    "    PiecewiseZeroSpreadedTermStructure::PiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding)\n"
    "    PiecewiseZeroSpreadedTermStructure::PiecewiseZeroSpreadedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseZeroSpreadedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseZeroSpreadedTermStructure *arg1 = (PiecewiseZeroSpreadedTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > tempshared1 ;
  ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseZeroSpreadedTermStructure" "', argument " "1"" of type '" "PiecewiseZeroSpreadedTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > * >(argp1);
      arg1 = const_cast< PiecewiseZeroSpreadedTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseZeroSpreadedTermStructure > * >(argp1);
      arg1 = const_cast< PiecewiseZeroSpreadedTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseZeroSpreadedTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseZeroSpreadedTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  Linear *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  arg7 = reinterpret_cast< Linear * >(argp7);
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SpreadedLinearZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (SpreadedLinearZeroInterpolatedTermStructure *)new SpreadedLinearZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedLinearZeroInterpolatedTermStructure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpreadedLinearZeroInterpolatedTermStructure", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SpreadedLinearZeroInterpolatedTermStructure__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SpreadedLinearZeroInterpolatedTermStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpreadedLinearZeroInterpolatedTermStructure::SpreadedLinearZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &,Linear const &)\n"
    "    SpreadedLinearZeroInterpolatedTermStructure::SpreadedLinearZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &)\n"
    "    SpreadedLinearZeroInterpolatedTermStructure::SpreadedLinearZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency)\n"
    "    SpreadedLinearZeroInterpolatedTermStructure::SpreadedLinearZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding)\n"
    "    SpreadedLinearZeroInterpolatedTermStructure::SpreadedLinearZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SpreadedLinearZeroInterpolatedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SpreadedLinearZeroInterpolatedTermStructure *arg1 = (SpreadedLinearZeroInterpolatedTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > tempshared1 ;
  ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadedLinearZeroInterpolatedTermStructure" "', argument " "1"" of type '" "SpreadedLinearZeroInterpolatedTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > * >(argp1);
      arg1 = const_cast< SpreadedLinearZeroInterpolatedTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SpreadedLinearZeroInterpolatedTermStructure > * >(argp1);
      arg1 = const_cast< SpreadedLinearZeroInterpolatedTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadedLinearZeroInterpolatedTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpreadedLinearZeroInterpolatedTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  BackwardFlat *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "7"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "7"" of type '" "BackwardFlat const &""'"); 
  }
  arg7 = reinterpret_cast< BackwardFlat * >(argp7);
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(BackwardFlat const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "2"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (SpreadedBackwardFlatZeroInterpolatedTermStructure *)new SpreadedBackwardFlatZeroInterpolatedTermStructure((Handle< YieldTermStructure > const &)*arg1,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartresult = result ? new ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpreadedBackwardFlatZeroInterpolatedTermStructure", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SpreadedBackwardFlatZeroInterpolatedTermStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpreadedBackwardFlatZeroInterpolatedTermStructure::SpreadedBackwardFlatZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &,BackwardFlat const &)\n"
    "    SpreadedBackwardFlatZeroInterpolatedTermStructure::SpreadedBackwardFlatZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency,DayCounter const &)\n"
    "    SpreadedBackwardFlatZeroInterpolatedTermStructure::SpreadedBackwardFlatZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding,Frequency)\n"
    "    SpreadedBackwardFlatZeroInterpolatedTermStructure::SpreadedBackwardFlatZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Compounding)\n"
    "    SpreadedBackwardFlatZeroInterpolatedTermStructure::SpreadedBackwardFlatZeroInterpolatedTermStructure(Handle< YieldTermStructure > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SpreadedBackwardFlatZeroInterpolatedTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SpreadedBackwardFlatZeroInterpolatedTermStructure *arg1 = (SpreadedBackwardFlatZeroInterpolatedTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > tempshared1 ;
  ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadedBackwardFlatZeroInterpolatedTermStructure" "', argument " "1"" of type '" "SpreadedBackwardFlatZeroInterpolatedTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > * >(argp1);
      arg1 = const_cast< SpreadedBackwardFlatZeroInterpolatedTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SpreadedBackwardFlatZeroInterpolatedTermStructure > * >(argp1);
      arg1 = const_cast< SpreadedBackwardFlatZeroInterpolatedTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatForward" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (FlatForward *)new FlatForward((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (FlatForward *)new FlatForward((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (FlatForward *)new FlatForward((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatForward" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (FlatForward *)new FlatForward((Date const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (FlatForward *)new FlatForward((Date const &)*arg1,arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (FlatForward *)new FlatForward((Date const &)*arg1,arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatForward" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FlatForward" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (FlatForward *)new FlatForward(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatForward" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  {
    try {
      result = (FlatForward *)new FlatForward(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (FlatForward *)new FlatForward(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatForward" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FlatForward" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (FlatForward *)new FlatForward(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatForward" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  {
    try {
      result = (FlatForward *)new FlatForward(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlatForward" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (FlatForward *)new FlatForward(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatForward > *smartresult = result ? new ext::shared_ptr<  FlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatForward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FlatForward", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FlatForward__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FlatForward__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FlatForward__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FlatForward__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FlatForward__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FlatForward__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlatForward__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlatForward__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlatForward__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlatForward__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FlatForward__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FlatForward__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FlatForward'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FlatForward::FlatForward(Date const &,Handle< Quote > const &,DayCounter const &,Compounding,Frequency)\n"
    "    FlatForward::FlatForward(Date const &,Handle< Quote > const &,DayCounter const &,Compounding)\n"
    "    FlatForward::FlatForward(Date const &,Handle< Quote > const &,DayCounter const &)\n"
    "    FlatForward::FlatForward(Date const &,Rate,DayCounter const &,Compounding,Frequency)\n"
    "    FlatForward::FlatForward(Date const &,Rate,DayCounter const &,Compounding)\n"
    "    FlatForward::FlatForward(Date const &,Rate,DayCounter const &)\n"
    "    FlatForward::FlatForward(Integer,Calendar const &,Handle< Quote > const &,DayCounter const &,Compounding,Frequency)\n"
    "    FlatForward::FlatForward(Integer,Calendar const &,Handle< Quote > const &,DayCounter const &,Compounding)\n"
    "    FlatForward::FlatForward(Integer,Calendar const &,Handle< Quote > const &,DayCounter const &)\n"
    "    FlatForward::FlatForward(Integer,Calendar const &,Rate,DayCounter const &,Compounding,Frequency)\n"
    "    FlatForward::FlatForward(Integer,Calendar const &,Rate,DayCounter const &,Compounding)\n"
    "    FlatForward::FlatForward(Integer,Calendar const &,Rate,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FlatForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FlatForward *arg1 = (FlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FlatForward > tempshared1 ;
  ext::shared_ptr< FlatForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlatForward" "', argument " "1"" of type '" "FlatForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FlatForward > * >(argp1);
      arg1 = const_cast< FlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FlatForward > * >(argp1);
      arg1 = const_cast< FlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FlatForward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FlatForward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FlatForward_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UltimateForwardTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  UltimateForwardTermStructure *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_UltimateForwardTermStructure", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UltimateForwardTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UltimateForwardTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UltimateForwardTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UltimateForwardTermStructure" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UltimateForwardTermStructure" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UltimateForwardTermStructure" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_UltimateForwardTermStructure" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UltimateForwardTermStructure" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UltimateForwardTermStructure" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (UltimateForwardTermStructure *)new UltimateForwardTermStructure((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UltimateForwardTermStructure > *smartresult = result ? new ext::shared_ptr<  UltimateForwardTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UltimateForwardTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UltimateForwardTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UltimateForwardTermStructure *arg1 = (UltimateForwardTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UltimateForwardTermStructure > tempshared1 ;
  ext::shared_ptr< UltimateForwardTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UltimateForwardTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UltimateForwardTermStructure" "', argument " "1"" of type '" "UltimateForwardTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UltimateForwardTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UltimateForwardTermStructure > * >(argp1);
      arg1 = const_cast< UltimateForwardTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UltimateForwardTermStructure > * >(argp1);
      arg1 = const_cast< UltimateForwardTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UltimateForwardTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UltimateForwardTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UltimateForwardTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CompositeZeroYieldStructure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  CompositeZeroYieldStructure< BinaryFunction > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeZeroYieldStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeZeroYieldStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompositeZeroYieldStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeZeroYieldStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  arg3 = swig_obj[2];
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CompositeZeroYieldStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CompositeZeroYieldStructure" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (CompositeZeroYieldStructure< BinaryFunction > *)new_CompositeZeroYieldStructure_Sl_BinaryFunction_Sg___SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> > *smartresult = result ? new ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CompositeZeroYieldStructure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  Compounding arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  CompositeZeroYieldStructure< BinaryFunction > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeZeroYieldStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeZeroYieldStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompositeZeroYieldStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeZeroYieldStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  arg3 = swig_obj[2];
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CompositeZeroYieldStructure" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  {
    try {
      result = (CompositeZeroYieldStructure< BinaryFunction > *)new_CompositeZeroYieldStructure_Sl_BinaryFunction_Sg___SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> > *smartresult = result ? new ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CompositeZeroYieldStructure__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  CompositeZeroYieldStructure< BinaryFunction > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeZeroYieldStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeZeroYieldStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompositeZeroYieldStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeZeroYieldStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  arg3 = swig_obj[2];
  {
    try {
      result = (CompositeZeroYieldStructure< BinaryFunction > *)new_CompositeZeroYieldStructure_Sl_BinaryFunction_Sg___SWIG_0((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> > *smartresult = result ? new ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CompositeZeroYieldStructure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CompositeZeroYieldStructure", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_new_CompositeZeroYieldStructure__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_CompositeZeroYieldStructure__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_CompositeZeroYieldStructure__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CompositeZeroYieldStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CompositeZeroYieldStructure< BinaryFunction >::CompositeZeroYieldStructure(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,PyObject *,Compounding,Frequency)\n"
    "    CompositeZeroYieldStructure< BinaryFunction >::CompositeZeroYieldStructure(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,PyObject *,Compounding)\n"
    "    CompositeZeroYieldStructure< BinaryFunction >::CompositeZeroYieldStructure(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CompositeZeroYieldStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompositeZeroYieldStructure< BinaryFunction > *arg1 = (CompositeZeroYieldStructure< BinaryFunction > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeZeroYieldStructure< BinaryFunction > > tempshared1 ;
  ext::shared_ptr< CompositeZeroYieldStructure< BinaryFunction > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositeZeroYieldStructure" "', argument " "1"" of type '" "CompositeZeroYieldStructure< BinaryFunction > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> > * >(argp1);
      arg1 = const_cast< CompositeZeroYieldStructure< BinaryFunction > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeZeroYieldStructure<BinaryFunction> > * >(argp1);
      arg1 = const_cast< CompositeZeroYieldStructure< BinaryFunction > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompositeZeroYieldStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompositeZeroYieldStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Handle< BlackVolTermStructure > arg4 ;
  Real arg5 ;
  Handle< BlackVolTermStructure > arg6 ;
  Real arg7 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  QuantoTermStructure *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoTermStructure", 8, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantoTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoTermStructure" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuantoTermStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoTermStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_QuantoTermStructure" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoTermStructure" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_QuantoTermStructure" "', argument " "4"" of type '" "Handle< BlackVolTermStructure >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoTermStructure" "', argument " "4"" of type '" "Handle< BlackVolTermStructure >""'");
    } else {
      Handle< BlackVolTermStructure > * temp = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_QuantoTermStructure" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_QuantoTermStructure" "', argument " "6"" of type '" "Handle< BlackVolTermStructure >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoTermStructure" "', argument " "6"" of type '" "Handle< BlackVolTermStructure >""'");
    } else {
      Handle< BlackVolTermStructure > * temp = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_QuantoTermStructure" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_QuantoTermStructure" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (QuantoTermStructure *)new QuantoTermStructure((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoTermStructure > *smartresult = result ? new ext::shared_ptr<  QuantoTermStructure >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoTermStructure_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoTermStructure *arg1 = (QuantoTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoTermStructure > tempshared1 ;
  ext::shared_ptr< QuantoTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoTermStructure" "', argument " "1"" of type '" "QuantoTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoTermStructure > * >(argp1);
      arg1 = const_cast< QuantoTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoTermStructure > * >(argp1);
      arg1 = const_cast< QuantoTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoTermStructure_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RealTimeSeries__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (TimeSeries< Real > *)new TimeSeries< Real >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RealTimeSeries__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  TimeSeries< Real > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RealTimeSeries" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RealTimeSeries" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RealTimeSeries" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RealTimeSeries" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (TimeSeries< Real > *)new_TimeSeries_Sl_Real_Sg___SWIG_1((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RealTimeSeries(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RealTimeSeries", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RealTimeSeries__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RealTimeSeries__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RealTimeSeries'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TimeSeries< Real >::TimeSeries()\n"
    "    TimeSeries< Real >::TimeSeries(std::vector< Date,std::allocator< Date > > const &,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RealTimeSeries_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealTimeSeries_dates" "', argument " "1"" of type '" "TimeSeries< Real > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< Real > * >(argp1);
  {
    try {
      result = (arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RealTimeSeries_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealTimeSeries_values" "', argument " "1"" of type '" "TimeSeries< Real > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< Real > * >(argp1);
  {
    try {
      result = (arg1)->values();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RealTimeSeries___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealTimeSeries___len__" "', argument " "1"" of type '" "TimeSeries< Real > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< Real > * >(argp1);
  {
    try {
      result = (arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RealTimeSeries___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "RealTimeSeries___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealTimeSeries___getitem__" "', argument " "1"" of type '" "TimeSeries< Real > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< Real > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RealTimeSeries___getitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RealTimeSeries___getitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (double)TimeSeries_Sl_Real_Sg____getitem__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RealTimeSeries___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  Date *arg2 = 0 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RealTimeSeries___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealTimeSeries___setitem__" "', argument " "1"" of type '" "TimeSeries< Real > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< Real > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RealTimeSeries___setitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RealTimeSeries___setitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealTimeSeries___setitem__" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  {
    try {
      TimeSeries_Sl_Real_Sg____setitem__(arg1,(Date const &)*arg2,(double const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RealTimeSeries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< Real > *arg1 = (TimeSeries< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealTimeSeries" "', argument " "1"" of type '" "TimeSeries< Real > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< Real > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RealTimeSeries_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RealTimeSeries_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IntervalPriceTimeSeries__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (TimeSeries< IntervalPrice > *)new TimeSeries< IntervalPrice >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceTimeSeries__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< IntervalPrice,std::allocator< IntervalPrice > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  TimeSeries< IntervalPrice > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntervalPriceTimeSeries" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntervalPriceTimeSeries" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntervalPriceTimeSeries" "', argument " "2"" of type '" "std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntervalPriceTimeSeries" "', argument " "2"" of type '" "std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< IntervalPrice,std::allocator< IntervalPrice > > * >(argp2);
  {
    try {
      result = (TimeSeries< IntervalPrice > *)new_TimeSeries_Sl_IntervalPrice_Sg___SWIG_1((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceTimeSeries(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntervalPriceTimeSeries", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IntervalPriceTimeSeries__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IntervalPriceTimeSeries__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntervalPriceTimeSeries'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TimeSeries< IntervalPrice >::TimeSeries()\n"
    "    TimeSeries< IntervalPrice >::TimeSeries(std::vector< Date,std::allocator< Date > > const &,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceTimeSeries_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceTimeSeries_dates" "', argument " "1"" of type '" "TimeSeries< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceTimeSeries_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice,std::allocator< IntervalPrice > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceTimeSeries_values" "', argument " "1"" of type '" "TimeSeries< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->values();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< IntervalPrice,std::allocator< IntervalPrice > >(result)), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceTimeSeries___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceTimeSeries___len__" "', argument " "1"" of type '" "TimeSeries< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceTimeSeries___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< IntervalPrice > result;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceTimeSeries___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceTimeSeries___getitem__" "', argument " "1"" of type '" "TimeSeries< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntervalPriceTimeSeries___getitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceTimeSeries___getitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = TimeSeries_Sl_IntervalPrice_Sg____getitem__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new IntervalPrice(result)), SWIGTYPE_p_IntervalPrice, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceTimeSeries___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  Date *arg2 = 0 ;
  IntervalPrice *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceTimeSeries___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceTimeSeries___setitem__" "', argument " "1"" of type '" "TimeSeries< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntervalPriceTimeSeries___setitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceTimeSeries___setitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPriceTimeSeries___setitem__" "', argument " "3"" of type '" "IntervalPrice const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceTimeSeries___setitem__" "', argument " "3"" of type '" "IntervalPrice const &""'"); 
  }
  arg3 = reinterpret_cast< IntervalPrice * >(argp3);
  {
    try {
      TimeSeries_Sl_IntervalPrice_Sg____setitem__(arg1,(Date const &)*arg2,(IntervalPrice const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntervalPriceTimeSeries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > *arg1 = (TimeSeries< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntervalPriceTimeSeries" "', argument " "1"" of type '" "TimeSeries< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntervalPriceTimeSeries_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntervalPriceTimeSeries_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_IntervalPriceVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_iterator" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_IntervalPrice_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___nonzero__" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_IntervalPrice_Sg____nonzero__((std::vector< IntervalPrice > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___bool__" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_IntervalPrice_Sg____bool__((std::vector< IntervalPrice > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___len__" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = std_vector_Sl_IntervalPrice_Sg____len__((std::vector< IntervalPrice > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  std::vector< IntervalPrice >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< IntervalPrice,std::allocator< IntervalPrice > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___getslice__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___getslice__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPriceVector___getslice__" "', argument " "3"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< IntervalPrice >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< IntervalPrice,std::allocator< IntervalPrice > > *)std_vector_Sl_IntervalPrice_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  std::vector< IntervalPrice >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___setslice__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___setslice__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPriceVector___setslice__" "', argument " "3"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< IntervalPrice >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  std::vector< IntervalPrice >::difference_type arg3 ;
  std::vector< IntervalPrice,std::allocator< IntervalPrice > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___setslice__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___setslice__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPriceVector___setslice__" "', argument " "3"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< IntervalPrice >::difference_type >(val3);
  {
    std::vector< IntervalPrice,std::allocator< IntervalPrice > > *ptr = (std::vector< IntervalPrice,std::allocator< IntervalPrice > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntervalPriceVector___setslice__" "', argument " "4"" of type '" "std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector___setslice__" "', argument " "4"" of type '" "std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntervalPriceVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IntervalPriceVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::__setslice__(std::vector< IntervalPrice >::difference_type,std::vector< IntervalPrice >::difference_type)\n"
    "    std::vector< IntervalPrice >::__setslice__(std::vector< IntervalPrice >::difference_type,std::vector< IntervalPrice >::difference_type,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  std::vector< IntervalPrice >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___delslice__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___delslice__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPriceVector___delslice__" "', argument " "3"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< IntervalPrice >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___delitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___delitem__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< IntervalPrice,std::allocator< IntervalPrice > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___getitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< IntervalPrice,std::allocator< IntervalPrice > > *)std_vector_Sl_IntervalPrice_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< IntervalPrice,std::allocator< IntervalPrice > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___setitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< IntervalPrice,std::allocator< IntervalPrice > > *ptr = (std::vector< IntervalPrice,std::allocator< IntervalPrice > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPriceVector___setitem__" "', argument " "3"" of type '" "std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector___setitem__" "', argument " "3"" of type '" "std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___setitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___delitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntervalPriceVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntervalPriceVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::__delitem__(std::vector< IntervalPrice >::difference_type)\n"
    "    std::vector< IntervalPrice >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< IntervalPrice >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___getitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___getitem__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< IntervalPrice >::value_type *) &std_vector_Sl_IntervalPrice_Sg____getitem____SWIG_1((std::vector< IntervalPrice > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntervalPrice, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< IntervalPrice >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntervalPriceVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntervalPriceVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< IntervalPrice >::__getitem__(std::vector< IntervalPrice >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::difference_type arg2 ;
  std::vector< IntervalPrice >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector___setitem__" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector___setitem__" "', argument " "2"" of type '" "std::vector< IntervalPrice >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPriceVector___setitem__" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector___setitem__" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_IntervalPrice_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(IntervalPrice const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntervalPriceVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntervalPriceVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_IntervalPrice, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntervalPriceVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< IntervalPrice,std::allocator< IntervalPrice > > const &)\n"
    "    std::vector< IntervalPrice >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< IntervalPrice >::__setitem__(std::vector< IntervalPrice >::difference_type,std::vector< IntervalPrice >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< IntervalPrice > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_pop" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_IntervalPrice_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< IntervalPrice >::value_type(result)), SWIGTYPE_p_IntervalPrice, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_append" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntervalPriceVector_append" "', argument " "2"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_append" "', argument " "2"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_IntervalPrice_Sg__append(arg1,(IntervalPrice const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< IntervalPrice > *)new std::vector< IntervalPrice >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< IntervalPrice > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< IntervalPrice,std::allocator< IntervalPrice > > *ptr = (std::vector< IntervalPrice,std::allocator< IntervalPrice > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntervalPriceVector" "', argument " "1"" of type '" "std::vector< IntervalPrice > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntervalPriceVector" "', argument " "1"" of type '" "std::vector< IntervalPrice > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< IntervalPrice > *)new std::vector< IntervalPrice >((std::vector< IntervalPrice > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_empty" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (bool)((std::vector< IntervalPrice > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_size" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = ((std::vector< IntervalPrice > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_swap" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntervalPriceVector_swap" "', argument " "2"" of type '" "std::vector< IntervalPrice > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_swap" "', argument " "2"" of type '" "std::vector< IntervalPrice > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< IntervalPrice > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_begin" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_end" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_rbegin" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_rend" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_clear" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< IntervalPrice > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_get_allocator" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = ((std::vector< IntervalPrice > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< IntervalPrice >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_IntervalPrice_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< IntervalPrice > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntervalPriceVector" "', argument " "1"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg1 = static_cast< std::vector< IntervalPrice >::size_type >(val1);
  {
    try {
      result = (std::vector< IntervalPrice > *)new std::vector< IntervalPrice >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_pop_back" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_resize" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector_resize" "', argument " "2"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< IntervalPrice >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_erase" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_erase" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_erase" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_IntervalPrice_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::iterator arg2 ;
  std::vector< IntervalPrice >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< IntervalPrice >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_erase" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_erase" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_erase" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_erase" "', argument " "3"" of type '" "std::vector< IntervalPrice >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_erase" "', argument " "3"" of type '" "std::vector< IntervalPrice >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_IntervalPrice_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_IntervalPriceVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_IntervalPriceVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::erase(std::vector< IntervalPrice >::iterator)\n"
    "    std::vector< IntervalPrice >::erase(std::vector< IntervalPrice >::iterator,std::vector< IntervalPrice >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice >::size_type arg1 ;
  std::vector< IntervalPrice >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< IntervalPrice > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntervalPriceVector" "', argument " "1"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg1 = static_cast< std::vector< IntervalPrice >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntervalPriceVector" "', argument " "2"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntervalPriceVector" "', argument " "2"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp2);
  {
    try {
      result = (std::vector< IntervalPrice > *)new std::vector< IntervalPrice >(arg1,(std::vector< IntervalPrice >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntervalPriceVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntervalPriceVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IntervalPriceVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IntervalPriceVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IntervalPriceVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IntervalPrice, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IntervalPriceVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntervalPriceVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::vector()\n"
    "    std::vector< IntervalPrice >::vector(std::vector< IntervalPrice > const &)\n"
    "    std::vector< IntervalPrice >::vector(std::vector< IntervalPrice >::size_type)\n"
    "    std::vector< IntervalPrice >::vector(std::vector< IntervalPrice >::size_type,std::vector< IntervalPrice >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_push_back" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntervalPriceVector_push_back" "', argument " "2"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_push_back" "', argument " "2"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< IntervalPrice >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_front" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (std::vector< IntervalPrice >::value_type *) &((std::vector< IntervalPrice > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntervalPrice, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< IntervalPrice >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_back" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = (std::vector< IntervalPrice >::value_type *) &((std::vector< IntervalPrice > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntervalPrice, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< IntervalPrice >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type arg2 ;
  std::vector< IntervalPrice >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_assign" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector_assign" "', argument " "2"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPriceVector_assign" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_assign" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< IntervalPrice >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type arg2 ;
  std::vector< IntervalPrice >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_resize" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector_resize" "', argument " "2"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPriceVector_resize" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_resize" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< IntervalPrice >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntervalPriceVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_IntervalPrice, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntervalPriceVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::resize(std::vector< IntervalPrice >::size_type)\n"
    "    std::vector< IntervalPrice >::resize(std::vector< IntervalPrice >::size_type,std::vector< IntervalPrice >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::iterator arg2 ;
  std::vector< IntervalPrice >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< IntervalPrice >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_insert" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_insert" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_insert" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPriceVector_insert" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_insert" "', argument " "3"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_IntervalPrice_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(IntervalPrice const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< IntervalPrice >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::iterator arg2 ;
  std::vector< IntervalPrice >::size_type arg3 ;
  std::vector< IntervalPrice >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_insert" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_insert" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntervalPriceVector_insert" "', argument " "2"" of type '" "std::vector< IntervalPrice >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPriceVector_insert" "', argument " "3"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg3 = static_cast< std::vector< IntervalPrice >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_IntervalPrice,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntervalPriceVector_insert" "', argument " "4"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPriceVector_insert" "', argument " "4"" of type '" "std::vector< IntervalPrice >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< IntervalPrice >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_IntervalPrice_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(IntervalPrice const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntervalPriceVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_IntervalPrice, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntervalPriceVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< IntervalPrice,std::allocator< IntervalPrice > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< IntervalPrice >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_IntervalPrice, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IntervalPriceVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntervalPriceVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< IntervalPrice >::insert(std::vector< IntervalPrice >::iterator,std::vector< IntervalPrice >::value_type const &)\n"
    "    std::vector< IntervalPrice >::insert(std::vector< IntervalPrice >::iterator,std::vector< IntervalPrice >::size_type,std::vector< IntervalPrice >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  std::vector< IntervalPrice >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPriceVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_reserve" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPriceVector_reserve" "', argument " "2"" of type '" "std::vector< IntervalPrice >::size_type""'");
  } 
  arg2 = static_cast< std::vector< IntervalPrice >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPriceVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< IntervalPrice >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPriceVector_capacity" "', argument " "1"" of type '" "std::vector< IntervalPrice > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      result = ((std::vector< IntervalPrice > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntervalPriceVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< IntervalPrice > *arg1 = (std::vector< IntervalPrice > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntervalPriceVector" "', argument " "1"" of type '" "std::vector< IntervalPrice > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< IntervalPrice > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntervalPriceVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_IntervalPrice_std__allocatorT_IntervalPrice_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntervalPriceVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IntervalPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  IntervalPrice *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IntervalPrice", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntervalPrice" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntervalPrice" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IntervalPrice" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IntervalPrice" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (IntervalPrice *)new IntervalPrice(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntervalPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_setValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real arg2 ;
  IntervalPrice::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPrice_setValue", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_setValue" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPrice_setValue" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPrice_setValue" "', argument " "3"" of type '" "IntervalPrice::Type""'");
  } 
  arg3 = static_cast< IntervalPrice::Type >(val3);
  {
    try {
      (arg1)->setValue(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPrice_setValues", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_setValues" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPrice_setValues" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntervalPrice_setValues" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntervalPrice_setValues" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IntervalPrice_setValues" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      (arg1)->setValues(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  IntervalPrice::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPrice_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_value" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPrice_value" "', argument " "2"" of type '" "IntervalPrice::Type""'");
  } 
  arg2 = static_cast< IntervalPrice::Type >(val2);
  {
    try {
      result = (Real)(arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_open(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_open" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  {
    try {
      result = (Real)(arg1)->open();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_close(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_close" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  {
    try {
      result = (Real)(arg1)->close();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_high(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_high" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  {
    try {
      result = (Real)(arg1)->high();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_low(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_low" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  {
    try {
      result = (Real)(arg1)->low();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_makeSeries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PyObject *swig_obj[5] ;
  TimeSeries< IntervalPrice > result;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPrice_makeSeries", 5, 5, swig_obj)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_makeSeries" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_makeSeries" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntervalPrice_makeSeries" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_makeSeries" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntervalPrice_makeSeries" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_makeSeries" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntervalPrice_makeSeries" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_makeSeries" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IntervalPrice_makeSeries" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_makeSeries" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = IntervalPrice::makeSeries((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< IntervalPrice >(result)), SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_extractValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > arg1 ;
  IntervalPrice::Type arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPrice_extractValues", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_extractValues" "', argument " "1"" of type '" "TimeSeries< IntervalPrice >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_extractValues" "', argument " "1"" of type '" "TimeSeries< IntervalPrice >""'");
    } else {
      TimeSeries< IntervalPrice > * temp = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPrice_extractValues" "', argument " "2"" of type '" "IntervalPrice::Type""'");
  } 
  arg2 = static_cast< IntervalPrice::Type >(val2);
  {
    try {
      result = IntervalPrice::extractValues(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntervalPrice_extractComponent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeSeries< IntervalPrice > arg1 ;
  IntervalPrice::Type arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Real > result;
  
  if (!SWIG_Python_UnpackTuple(args, "IntervalPrice_extractComponent", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntervalPrice_extractComponent" "', argument " "1"" of type '" "TimeSeries< IntervalPrice >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntervalPrice_extractComponent" "', argument " "1"" of type '" "TimeSeries< IntervalPrice >""'");
    } else {
      TimeSeries< IntervalPrice > * temp = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntervalPrice_extractComponent" "', argument " "2"" of type '" "IntervalPrice::Type""'");
  } 
  arg2 = static_cast< IntervalPrice::Type >(val2);
  {
    try {
      result = IntervalPrice::extractComponent(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Real >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntervalPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntervalPrice *arg1 = (IntervalPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IntervalPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntervalPrice" "', argument " "1"" of type '" "IntervalPrice *""'"); 
  }
  arg1 = reinterpret_cast< IntervalPrice * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntervalPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_IntervalPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntervalPrice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_IndexManager_instance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IndexManager_instance", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (IndexManager *) &IndexManager::instance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IndexManager, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_setHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  TimeSeries< Real > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IndexManager_setHistory", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_setHistory" "', argument " "1"" of type '" "IndexManager *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndexManager_setHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_setHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndexManager_setHistory" "', argument " "3"" of type '" "TimeSeries< Real > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_setHistory" "', argument " "3"" of type '" "TimeSeries< Real > const &""'"); 
  }
  arg3 = reinterpret_cast< TimeSeries< Real > * >(argp3);
  {
    try {
      (arg1)->setHistory((std::string const &)*arg2,(TimeSeries< Real > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_getHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  TimeSeries< Real > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "IndexManager_getHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_getHistory" "', argument " "1"" of type '" "IndexManager const *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndexManager_getHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_getHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (TimeSeries< Real > *) &((IndexManager const *)arg1)->getHistory((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_hasHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "IndexManager_hasHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_hasHistory" "', argument " "1"" of type '" "IndexManager const *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndexManager_hasHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_hasHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)((IndexManager const *)arg1)->hasHistory((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_histories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_histories" "', argument " "1"" of type '" "IndexManager const *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    try {
      result = ((IndexManager const *)arg1)->histories();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_clearHistory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "IndexManager_clearHistory", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_clearHistory" "', argument " "1"" of type '" "IndexManager *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndexManager_clearHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_clearHistory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->clearHistory((std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_clearHistories(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_clearHistories" "', argument " "1"" of type '" "IndexManager *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    try {
      (arg1)->clearHistories();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexManager_hasHistoricalFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  std::string *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "IndexManager_hasHistoricalFixing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexManager_hasHistoricalFixing" "', argument " "1"" of type '" "IndexManager const *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndexManager_hasHistoricalFixing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_hasHistoricalFixing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndexManager_hasHistoricalFixing" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IndexManager_hasHistoricalFixing" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (bool)((IndexManager const *)arg1)->hasHistoricalFixing((std::string const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IndexManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexManager *arg1 = (IndexManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IndexManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndexManager" "', argument " "1"" of type '" "IndexManager *""'"); 
  }
  arg1 = reinterpret_cast< IndexManager * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IndexManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_IndexManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Index_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_name" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Index const *)arg1)->name();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_fixingCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_fixingCalendar" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Index const *)arg1)->fixingCalendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_isValidFixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Index_isValidFixingDate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_isValidFixingDate" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_isValidFixingDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_isValidFixingDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)((Index const *)arg1)->isValidFixingDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_hasHistoricalFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Index_hasHistoricalFixing", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_hasHistoricalFixing" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_hasHistoricalFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_hasHistoricalFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)((Index const *)arg1)->hasHistoricalFixing((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_fixing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_fixing" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_fixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_fixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Index_fixing" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)((Index const *)arg1)->fixing((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_fixing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_fixing" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_fixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_fixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)((Index const *)arg1)->fixing((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_fixing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Index_fixing", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Index_fixing__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Index_fixing__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Index_fixing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Index::fixing(Date const &,bool) const\n"
    "    Index::fixing(Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Index_addFixing__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_addFixing" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_addFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_addFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Index_addFixing" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Index_addFixing" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      (arg1)->addFixing((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_addFixing__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_addFixing" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_addFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_addFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Index_addFixing" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      (arg1)->addFixing((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_addFixing(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Index_addFixing", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Index_addFixing__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Index_addFixing__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Index_addFixing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Index::addFixing(Date const &,Rate,bool)\n"
    "    Index::addFixing(Date const &,Rate)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Index_timeSeries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index const > tempshared1 ;
  ext::shared_ptr< Index const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeSeries< Real > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_timeSeries" "', argument " "1"" of type '" "Index const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (TimeSeries< Real > *) &((Index const *)arg1)->timeSeries();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_clearFixings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_clearFixings" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->clearFixings();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_addFixings__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_addFixings" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_addFixings" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_addFixings" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Index_addFixings" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_addFixings" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Index_addFixings" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      Index_addFixings__SWIG_0(arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_addFixings__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index_addFixings" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Index_addFixings" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_addFixings" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Index_addFixings" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Index_addFixings" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      Index_addFixings__SWIG_0(arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Index_addFixings(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Index_addFixings", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Index_addFixings__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Index_addFixings__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Index_addFixings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Index::addFixings(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,bool)\n"
    "    Index::addFixings(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Index___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Index___str__" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = Index___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Index *arg1 = (Index *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  ext::shared_ptr< Index > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Index" "', argument " "1"" of type '" "Index *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Index > * >(argp1);
      arg1 = const_cast< Index * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Index_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Index_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_InterestRateIndex_familyName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_familyName" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterestRateIndex const *)arg1)->familyName();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_tenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_tenor" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterestRateIndex const *)arg1)->tenor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_fixingDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Natural result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_fixingDays" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Natural)((InterestRateIndex const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_fixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateIndex_fixingDate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_fixingDate" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRateIndex_fixingDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateIndex_fixingDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((InterestRateIndex const *)arg1)->fixingDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_currency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Currency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_currency" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterestRateIndex const *)arg1)->currency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Currency(result)), SWIGTYPE_p_Currency, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_dayCounter" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterestRateIndex const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateIndex_maturityDate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_maturityDate" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRateIndex_maturityDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateIndex_maturityDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((InterestRateIndex const *)arg1)->maturityDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InterestRateIndex_valueDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex const > tempshared1 ;
  ext::shared_ptr< InterestRateIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "InterestRateIndex_valueDate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterestRateIndex_valueDate" "', argument " "1"" of type '" "InterestRateIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterestRateIndex_valueDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterestRateIndex_valueDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((InterestRateIndex const *)arg1)->valueDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InterestRateIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterestRateIndex *arg1 = (InterestRateIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared1 ;
  ext::shared_ptr< InterestRateIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterestRateIndex" "', argument " "1"" of type '" "InterestRateIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterestRateIndex > * >(argp1);
      arg1 = const_cast< InterestRateIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InterestRateIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IborIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  IborIndex *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IborIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IborIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IborIndex" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IborIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  arg4 = reinterpret_cast< Currency * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_IborIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IborIndex" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_IborIndex" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_IborIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_IborIndex" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  {
    try {
      result = (IborIndex *)new IborIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = result ? new ext::shared_ptr<  IborIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IborIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  IborIndex *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IborIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IborIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IborIndex" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IborIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  arg4 = reinterpret_cast< Currency * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_IborIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IborIndex" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_IborIndex" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_IborIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (IborIndex *)new IborIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = result ? new ext::shared_ptr<  IborIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IborIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IborIndex", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_IborIndex__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_IborIndex__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IborIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IborIndex::IborIndex(std::string const &,Period const &,Integer,Currency const &,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Handle< YieldTermStructure > const &)\n"
    "    IborIndex::IborIndex(std::string const &,Period const &,Integer,Currency const &,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IborIndex_businessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborIndex *arg1 = (IborIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex const > tempshared1 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborIndex_businessDayConvention" "', argument " "1"" of type '" "IborIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)((IborIndex const *)arg1)->businessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborIndex_endOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborIndex *arg1 = (IborIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex const > tempshared1 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborIndex_endOfMonth" "', argument " "1"" of type '" "IborIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((IborIndex const *)arg1)->endOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborIndex_forwardingTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborIndex *arg1 = (IborIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex const > tempshared1 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborIndex_forwardingTermStructure" "', argument " "1"" of type '" "IborIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((IborIndex const *)arg1)->forwardingTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborIndex_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborIndex *arg1 = (IborIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex const > tempshared1 ;
  ext::shared_ptr< IborIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< IborIndex > result;
  
  if (!SWIG_Python_UnpackTuple(args, "IborIndex_clone", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborIndex_clone" "', argument " "1"" of type '" "IborIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IborIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = ((IborIndex const *)arg1)->clone((Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = result ? new ext::shared_ptr<  IborIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IborIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborIndex *arg1 = (IborIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex > tempshared1 ;
  ext::shared_ptr< IborIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IborIndex" "', argument " "1"" of type '" "IborIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IborIndex > * >(argp1);
      arg1 = const_cast< IborIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IborIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IborIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_iborindex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< InterestRateIndex > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< IborIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_iborindex" "', argument " "1"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_iborindex((ext::shared_ptr< InterestRateIndex > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = result ? new ext::shared_ptr<  IborIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Integer arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int 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 ;
  OvernightIndex *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndex" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndex" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  arg3 = reinterpret_cast< Currency * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndex" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndex" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndex" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (OvernightIndex *)new OvernightIndex((std::string const &)*arg1,arg2,(Currency const &)*arg3,(Calendar const &)*arg4,(DayCounter const &)*arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Integer arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  OvernightIndex *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndex" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndex" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  arg3 = reinterpret_cast< Currency * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndex" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndex" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndex" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (OvernightIndex *)new OvernightIndex((std::string const &)*arg1,arg2,(Currency const &)*arg3,(Calendar const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndex", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_OvernightIndex__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_OvernightIndex__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIndex::OvernightIndex(std::string const &,Integer,Currency const &,Calendar const &,DayCounter const &,Handle< YieldTermStructure > const &)\n"
    "    OvernightIndex::OvernightIndex(std::string const &,Integer,Currency const &,Calendar const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndex_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndex *arg1 = (OvernightIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndex const > tempshared1 ;
  ext::shared_ptr< OvernightIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< OvernightIndex > result;
  
  if (!SWIG_Python_UnpackTuple(args, "OvernightIndex_clone", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndex_clone" "', argument " "1"" of type '" "OvernightIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndex > * >(argp1);
      arg1 = const_cast< OvernightIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndex > * >(argp1);
      arg1 = const_cast< OvernightIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OvernightIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = OvernightIndex_clone((OvernightIndex const *)arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndex *arg1 = (OvernightIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared1 ;
  ext::shared_ptr< OvernightIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndex" "', argument " "1"" of type '" "OvernightIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndex > * >(argp1);
      arg1 = const_cast< OvernightIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndex > * >(argp1);
      arg1 = const_cast< OvernightIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Libor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int 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 ;
  Libor *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Libor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Libor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Libor" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Libor" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  arg4 = reinterpret_cast< Currency * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Libor" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Libor" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Libor" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    try {
      result = (Libor *)new Libor((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(DayCounter const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Libor > *smartresult = result ? new ext::shared_ptr<  Libor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Libor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Libor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Libor *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Libor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Libor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Libor" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Libor" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  arg4 = reinterpret_cast< Currency * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Libor" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Libor" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Libor" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (Libor *)new Libor((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Libor > *smartresult = result ? new ext::shared_ptr<  Libor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Libor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Libor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Libor", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Libor__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_Libor__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Libor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Libor::Libor(std::string const &,Period const &,Natural,Currency const &,Calendar const &,DayCounter const &,Handle< YieldTermStructure > const &)\n"
    "    Libor::Libor(std::string const &,Period const &,Natural,Currency const &,Calendar const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Libor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Libor *arg1 = (Libor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Libor > tempshared1 ;
  ext::shared_ptr< Libor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Libor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Libor" "', argument " "1"" of type '" "Libor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Libor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Libor > * >(argp1);
      arg1 = const_cast< Libor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Libor > * >(argp1);
      arg1 = const_cast< Libor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Libor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Libor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Libor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DailyTenorLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Natural arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int 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 ;
  DailyTenorLibor *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DailyTenorLibor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DailyTenorLibor" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DailyTenorLibor" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  arg3 = reinterpret_cast< Currency * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DailyTenorLibor" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DailyTenorLibor" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_DailyTenorLibor" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (DailyTenorLibor *)new DailyTenorLibor((std::string const &)*arg1,arg2,(Currency const &)*arg3,(Calendar const &)*arg4,(DayCounter const &)*arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DailyTenorLibor > *smartresult = result ? new ext::shared_ptr<  DailyTenorLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DailyTenorLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DailyTenorLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Natural arg2 ;
  Currency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  DailyTenorLibor *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DailyTenorLibor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DailyTenorLibor" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DailyTenorLibor" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  arg3 = reinterpret_cast< Currency * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DailyTenorLibor" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DailyTenorLibor" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DailyTenorLibor" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (DailyTenorLibor *)new DailyTenorLibor((std::string const &)*arg1,arg2,(Currency const &)*arg3,(Calendar const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DailyTenorLibor > *smartresult = result ? new ext::shared_ptr<  DailyTenorLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DailyTenorLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DailyTenorLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DailyTenorLibor", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_DailyTenorLibor__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_DailyTenorLibor__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DailyTenorLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DailyTenorLibor::DailyTenorLibor(std::string const &,Natural,Currency const &,Calendar const &,DayCounter const &,Handle< YieldTermStructure > const &)\n"
    "    DailyTenorLibor::DailyTenorLibor(std::string const &,Natural,Currency const &,Calendar const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DailyTenorLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DailyTenorLibor *arg1 = (DailyTenorLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DailyTenorLibor > tempshared1 ;
  ext::shared_ptr< DailyTenorLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DailyTenorLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DailyTenorLibor" "', argument " "1"" of type '" "DailyTenorLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DailyTenorLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DailyTenorLibor > * >(argp1);
      arg1 = const_cast< DailyTenorLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DailyTenorLibor > * >(argp1);
      arg1 = const_cast< DailyTenorLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DailyTenorLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DailyTenorLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DailyTenorLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SwapIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  Period *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  DayCounter *arg8 = 0 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< IborIndex > tempshared9 ;
  SwapIndex *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SwapIndex" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  arg4 = reinterpret_cast< Currency * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwapIndex" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapIndex" "', argument " "9"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9) : &tempshared9;
    }
  }
  {
    try {
      result = (SwapIndex *)new SwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(Period const &)*arg6,arg7,(DayCounter const &)*arg8,(ext::shared_ptr< IborIndex > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Currency *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  Period *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  DayCounter *arg8 = 0 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< IborIndex > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  SwapIndex *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SwapIndex" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "4"" of type '" "Currency const &""'"); 
  }
  arg4 = reinterpret_cast< Currency * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwapIndex" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapIndex" "', argument " "9"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapIndex" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndex" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (SwapIndex *)new SwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,(Currency const &)*arg4,(Calendar const &)*arg5,(Period const &)*arg6,arg7,(DayCounter const &)*arg8,(ext::shared_ptr< IborIndex > const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwapIndex", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_SwapIndex__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_SwapIndex__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwapIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwapIndex::SwapIndex(std::string const &,Period const &,Integer,Currency const &,Calendar const &,Period const &,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &)\n"
    "    SwapIndex::SwapIndex(std::string const &,Period const &,Integer,Currency const &,Calendar const &,Period const &,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndex_fixedLegTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_fixedLegTenor" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwapIndex const *)arg1)->fixedLegTenor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_fixedLegConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_fixedLegConvention" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)((SwapIndex const *)arg1)->fixedLegConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_iborIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< IborIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_iborIndex" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwapIndex const *)arg1)->iborIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = result ? new ext::shared_ptr<  IborIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_forwardingTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_forwardingTermStructure" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwapIndex const *)arg1)->forwardingTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_discountingTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_discountingTermStructure" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwapIndex const *)arg1)->discountingTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_clone__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_clone" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = ((SwapIndex const *)arg1)->clone((Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_clone__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_clone" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwapIndex_clone" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndex_clone" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = ((SwapIndex const *)arg1)->clone((Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_clone__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex const > tempshared1 ;
  ext::shared_ptr< SwapIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndex_clone" "', argument " "1"" of type '" "SwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapIndex_clone" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndex_clone" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = ((SwapIndex const *)arg1)->clone((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndex_clone(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndex_clone", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwapIndex_clone__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwapIndex_clone__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwapIndex_clone__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndex_clone'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwapIndex::clone(Handle< YieldTermStructure > const &) const\n"
    "    SwapIndex::clone(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &) const\n"
    "    SwapIndex::clone(Period const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SwapIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapIndex *arg1 = (SwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared1 ;
  ext::shared_ptr< SwapIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwapIndex" "', argument " "1"" of type '" "SwapIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapIndex > * >(argp1);
      arg1 = const_cast< SwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwapIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwapIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SwapIndexVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____bool__((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____len__((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwapIndexVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwapIndexVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwapIndexVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *ptr = (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SwapIndexVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndexVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwapIndexVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SwapIndexVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__setslice__(std::vector< ext::shared_ptr< SwapIndex > >::difference_type,std::vector< ext::shared_ptr< SwapIndex > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__setslice__(std::vector< ext::shared_ptr< SwapIndex > >::difference_type,std::vector< ext::shared_ptr< SwapIndex > >::difference_type,std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwapIndexVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *)std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *ptr = (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwapIndexVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndexVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SwapIndexVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwapIndexVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__delitem__(std::vector< ext::shared_ptr< SwapIndex > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SwapIndex > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = *result ? new ext::shared_ptr<  SwapIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< SwapIndex > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SwapIndexVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwapIndexVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__getitem__(std::vector< ext::shared_ptr< SwapIndex > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwapIndexVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< SwapIndex > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SwapIndexVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwapIndexVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwapIndexVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::__setitem__(std::vector< ext::shared_ptr< SwapIndex > >::difference_type,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapIndexVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__append(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapIndexVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > > *)new std::vector< ext::shared_ptr< SwapIndex > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapIndexVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *ptr = (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapIndexVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapIndexVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > > *)new std::vector< ext::shared_ptr< SwapIndex > >((std::vector< ext::shared_ptr< SwapIndex > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapIndexVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapIndexVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< SwapIndex > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< SwapIndex > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapIndexVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapIndexVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > > *)new std::vector< ext::shared_ptr< SwapIndex > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_SwapIndexVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_SwapIndexVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::erase(std::vector< ext::shared_ptr< SwapIndex > >::iterator)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::erase(std::vector< ext::shared_ptr< SwapIndex > >::iterator,std::vector< ext::shared_ptr< SwapIndex > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SwapIndexVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg1 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< SwapIndex > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapIndexVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapIndexVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > > *)new std::vector< ext::shared_ptr< SwapIndex > >(arg1,(std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapIndexVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwapIndexVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SwapIndexVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SwapIndexVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SwapIndexVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SwapIndexVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwapIndexVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::vector()\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::vector(std::vector< ext::shared_ptr< SwapIndex > > const &)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::vector(std::vector< ext::shared_ptr< SwapIndex > >::size_type)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::vector(std::vector< ext::shared_ptr< SwapIndex > >::size_type,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapIndexVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > >::value_type *) &((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = *result ? new ext::shared_ptr<  SwapIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< SwapIndex > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< SwapIndex > >::value_type *) &((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = *result ? new ext::shared_ptr<  SwapIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< SwapIndex > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwapIndexVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwapIndexVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwapIndexVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwapIndexVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::resize(std::vector< ext::shared_ptr< SwapIndex > >::size_type)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::resize(std::vector< ext::shared_ptr< SwapIndex > >::size_type,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwapIndexVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< SwapIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SwapIndex > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::iterator arg2 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg3 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SwapIndexVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwapIndexVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SwapIndexVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SwapIndex_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< SwapIndex > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwapIndexVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwapIndexVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SwapIndex > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SwapIndexVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwapIndexVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::insert(std::vector< ext::shared_ptr< SwapIndex > >::iterator,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< SwapIndex > >::insert(std::vector< ext::shared_ptr< SwapIndex > >::iterator,std::vector< ext::shared_ptr< SwapIndex > >::size_type,std::vector< ext::shared_ptr< SwapIndex > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapIndexVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwapIndexVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SwapIndex > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapIndexVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SwapIndex > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapIndexVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< SwapIndex > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwapIndexVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SwapIndex > > *arg1 = (std::vector< ext::shared_ptr< SwapIndex > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwapIndexVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SwapIndex > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SwapIndex > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwapIndexVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SwapIndex_t_std__allocatorT_ext__shared_ptrT_SwapIndex_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwapIndexVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_swap_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< InterestRateIndex > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwapIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_swap_index" "', argument " "1"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_swap_index((ext::shared_ptr< InterestRateIndex > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapSpreadIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SwapSpreadIndex *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapSpreadIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapSpreadIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapSpreadIndex" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapSpreadIndex" "', argument " "3"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapSpreadIndex" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapSpreadIndex" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (SwapSpreadIndex *)new SwapSpreadIndex((std::string const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(ext::shared_ptr< SwapIndex > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapSpreadIndex > *smartresult = result ? new ext::shared_ptr<  SwapSpreadIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapSpreadIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  Real arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  SwapSpreadIndex *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapSpreadIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapSpreadIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapSpreadIndex" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapSpreadIndex" "', argument " "3"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapSpreadIndex" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (SwapSpreadIndex *)new SwapSpreadIndex((std::string const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(ext::shared_ptr< SwapIndex > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapSpreadIndex > *smartresult = result ? new ext::shared_ptr<  SwapSpreadIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapSpreadIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared3 ;
  SwapSpreadIndex *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapSpreadIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapSpreadIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapSpreadIndex" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapSpreadIndex" "', argument " "3"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (SwapSpreadIndex *)new SwapSpreadIndex((std::string const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(ext::shared_ptr< SwapIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapSpreadIndex > *smartresult = result ? new ext::shared_ptr<  SwapSpreadIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapSpreadIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwapSpreadIndex", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SwapSpreadIndex__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SwapSpreadIndex__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SwapSpreadIndex__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwapSpreadIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwapSpreadIndex::SwapSpreadIndex(std::string const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,Real const,Real const)\n"
    "    SwapSpreadIndex::SwapSpreadIndex(std::string const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,Real const)\n"
    "    SwapSpreadIndex::SwapSpreadIndex(std::string const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapSpreadIndex_forecastFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex const > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapSpreadIndex_forecastFixing", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapSpreadIndex_forecastFixing" "', argument " "1"" of type '" "SwapSpreadIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapSpreadIndex_forecastFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapSpreadIndex_forecastFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)((SwapSpreadIndex const *)arg1)->forecastFixing((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapSpreadIndex_pastFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex const > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwapSpreadIndex_pastFixing", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapSpreadIndex_pastFixing" "', argument " "1"" of type '" "SwapSpreadIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwapSpreadIndex_pastFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwapSpreadIndex_pastFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)((SwapSpreadIndex const *)arg1)->pastFixing((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapSpreadIndex_swapIndex1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwapIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapSpreadIndex_swapIndex1" "', argument " "1"" of type '" "SwapSpreadIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->swapIndex1();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapSpreadIndex_swapIndex2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwapIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapSpreadIndex_swapIndex2" "', argument " "1"" of type '" "SwapSpreadIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->swapIndex2();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapIndex > *smartresult = result ? new ext::shared_ptr<  SwapIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapSpreadIndex_gearing1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapSpreadIndex_gearing1" "', argument " "1"" of type '" "SwapSpreadIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->gearing1();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapSpreadIndex_gearing2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapSpreadIndex_gearing2" "', argument " "1"" of type '" "SwapSpreadIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->gearing2();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwapSpreadIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapSpreadIndex *arg1 = (SwapSpreadIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared1 ;
  ext::shared_ptr< SwapSpreadIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwapSpreadIndex" "', argument " "1"" of type '" "SwapSpreadIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapSpreadIndex > * >(argp1);
      arg1 = const_cast< SwapSpreadIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwapSpreadIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwapSpreadIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EquityIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Handle< YieldTermStructure > arg4 ;
  Handle< Quote > arg5 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  EquityIndex *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EquityIndex" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityIndex" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityIndex" "', argument " "4"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "4"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityIndex" "', argument " "5"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "5"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (EquityIndex *)new EquityIndex(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityIndex > *smartresult = result ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  Handle< YieldTermStructure > arg4 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  EquityIndex *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EquityIndex" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityIndex" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityIndex" "', argument " "4"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "4"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (EquityIndex *)new EquityIndex(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityIndex > *smartresult = result ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  Handle< YieldTermStructure > arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  EquityIndex *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EquityIndex" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityIndex" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "3"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (EquityIndex *)new EquityIndex(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityIndex > *smartresult = result ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityIndex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  SwigValueWrapper< Calendar > arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  EquityIndex *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EquityIndex" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityIndex" "', argument " "2"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (EquityIndex *)new EquityIndex(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityIndex > *smartresult = result ? new ext::shared_ptr<  EquityIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EquityIndex", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EquityIndex__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EquityIndex__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_EquityIndex__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_EquityIndex__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EquityIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EquityIndex::EquityIndex(std::string,Calendar,Handle< YieldTermStructure >,Handle< YieldTermStructure >,Handle< Quote >)\n"
    "    EquityIndex::EquityIndex(std::string,Calendar,Handle< YieldTermStructure >,Handle< YieldTermStructure >)\n"
    "    EquityIndex::EquityIndex(std::string,Calendar,Handle< YieldTermStructure >)\n"
    "    EquityIndex::EquityIndex(std::string,Calendar)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EquityIndex_equityInterestRateCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityIndex const > tempshared1 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityIndex_equityInterestRateCurve" "', argument " "1"" of type '" "EquityIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((EquityIndex const *)arg1)->equityInterestRateCurve();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityIndex_equityDividendCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityIndex const > tempshared1 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityIndex_equityDividendCurve" "', argument " "1"" of type '" "EquityIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((EquityIndex const *)arg1)->equityDividendCurve();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityIndex_spot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityIndex const > tempshared1 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityIndex_spot" "', argument " "1"" of type '" "EquityIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((EquityIndex const *)arg1)->spot();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityIndex_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityIndex const > tempshared1 ;
  ext::shared_ptr< EquityIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  ext::shared_ptr< EquityIndex > result;
  
  if (!SWIG_Python_UnpackTuple(args, "EquityIndex_clone", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityIndex_clone" "', argument " "1"" of type '" "EquityIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EquityIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EquityIndex_clone" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EquityIndex_clone" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EquityIndex_clone" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "EquityIndex_clone" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EquityIndex_clone" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = ((EquityIndex const *)arg1)->clone((Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityIndex > *smartresult = result ? new ext::shared_ptr<  EquityIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EquityIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityIndex *arg1 = (EquityIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityIndex > tempshared1 ;
  ext::shared_ptr< EquityIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquityIndex" "', argument " "1"" of type '" "EquityIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EquityIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EquityIndex > * >(argp1);
      arg1 = const_cast< EquityIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EquityIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EquityIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AUDLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  AUDLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AUDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AUDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AUDLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AUDLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (AUDLibor *)new AUDLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AUDLibor > *smartresult = result ? new ext::shared_ptr<  AUDLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AUDLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AUDLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  AUDLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AUDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AUDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (AUDLibor *)new AUDLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AUDLibor > *smartresult = result ? new ext::shared_ptr<  AUDLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AUDLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AUDLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AUDLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AUDLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AUDLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AUDLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AUDLibor::AUDLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    AUDLibor::AUDLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AUDLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AUDLibor *arg1 = (AUDLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AUDLibor > tempshared1 ;
  ext::shared_ptr< AUDLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AUDLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AUDLibor" "', argument " "1"" of type '" "AUDLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AUDLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AUDLibor > * >(argp1);
      arg1 = const_cast< AUDLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AUDLibor > * >(argp1);
      arg1 = const_cast< AUDLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AUDLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AUDLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AUDLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CADLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  CADLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CADLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CADLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CADLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CADLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (CADLibor *)new CADLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CADLibor > *smartresult = result ? new ext::shared_ptr<  CADLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CADLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CADLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CADLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CADLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CADLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (CADLibor *)new CADLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CADLibor > *smartresult = result ? new ext::shared_ptr<  CADLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CADLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CADLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CADLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CADLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CADLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CADLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CADLibor::CADLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    CADLibor::CADLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CADLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CADLibor *arg1 = (CADLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CADLibor > tempshared1 ;
  ext::shared_ptr< CADLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CADLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CADLibor" "', argument " "1"" of type '" "CADLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CADLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CADLibor > * >(argp1);
      arg1 = const_cast< CADLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CADLibor > * >(argp1);
      arg1 = const_cast< CADLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CADLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CADLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CADLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CADLiborON__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CADLiborON *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CADLiborON" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CADLiborON" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (CADLiborON *)new CADLiborON((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CADLiborON > *smartresult = result ? new ext::shared_ptr<  CADLiborON >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CADLiborON_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CADLiborON__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CADLiborON *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (CADLiborON *)new CADLiborON();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CADLiborON > *smartresult = result ? new ext::shared_ptr<  CADLiborON >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CADLiborON_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CADLiborON(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CADLiborON", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CADLiborON__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CADLiborON__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CADLiborON'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CADLiborON::CADLiborON(Handle< YieldTermStructure > const &)\n"
    "    CADLiborON::CADLiborON()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CADLiborON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CADLiborON *arg1 = (CADLiborON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CADLiborON > tempshared1 ;
  ext::shared_ptr< CADLiborON > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CADLiborON_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CADLiborON" "', argument " "1"" of type '" "CADLiborON *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CADLiborON > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CADLiborON > * >(argp1);
      arg1 = const_cast< CADLiborON * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CADLiborON > * >(argp1);
      arg1 = const_cast< CADLiborON * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CADLiborON_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CADLiborON_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CADLiborON_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Cdor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Cdor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Cdor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cdor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Cdor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cdor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Cdor *)new Cdor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Cdor > *smartresult = result ? new ext::shared_ptr<  Cdor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Cdor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cdor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Cdor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Cdor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cdor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Cdor *)new Cdor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Cdor > *smartresult = result ? new ext::shared_ptr<  Cdor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Cdor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Cdor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Cdor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Cdor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Cdor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Cdor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Cdor::Cdor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Cdor::Cdor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Cdor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Cdor *arg1 = (Cdor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Cdor > tempshared1 ;
  ext::shared_ptr< Cdor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Cdor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cdor" "', argument " "1"" of type '" "Cdor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Cdor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Cdor > * >(argp1);
      arg1 = const_cast< Cdor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Cdor > * >(argp1);
      arg1 = const_cast< Cdor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Cdor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Cdor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Cdor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CHFLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  CHFLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CHFLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CHFLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CHFLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CHFLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (CHFLibor *)new CHFLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CHFLibor > *smartresult = result ? new ext::shared_ptr<  CHFLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CHFLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CHFLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CHFLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CHFLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CHFLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (CHFLibor *)new CHFLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CHFLibor > *smartresult = result ? new ext::shared_ptr<  CHFLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CHFLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CHFLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CHFLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CHFLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CHFLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CHFLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CHFLibor::CHFLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    CHFLibor::CHFLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CHFLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CHFLibor *arg1 = (CHFLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CHFLibor > tempshared1 ;
  ext::shared_ptr< CHFLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CHFLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CHFLibor" "', argument " "1"" of type '" "CHFLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CHFLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CHFLibor > * >(argp1);
      arg1 = const_cast< CHFLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CHFLibor > * >(argp1);
      arg1 = const_cast< CHFLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CHFLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CHFLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CHFLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DKKLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  DKKLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DKKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DKKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DKKLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DKKLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (DKKLibor *)new DKKLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DKKLibor > *smartresult = result ? new ext::shared_ptr<  DKKLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DKKLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DKKLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DKKLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DKKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DKKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (DKKLibor *)new DKKLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DKKLibor > *smartresult = result ? new ext::shared_ptr<  DKKLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DKKLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DKKLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DKKLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DKKLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DKKLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DKKLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DKKLibor::DKKLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    DKKLibor::DKKLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DKKLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DKKLibor *arg1 = (DKKLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DKKLibor > tempshared1 ;
  ext::shared_ptr< DKKLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DKKLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DKKLibor" "', argument " "1"" of type '" "DKKLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DKKLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DKKLibor > * >(argp1);
      arg1 = const_cast< DKKLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DKKLibor > * >(argp1);
      arg1 = const_cast< DKKLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DKKLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DKKLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DKKLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Bbsw *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bbsw" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Bbsw *)new Bbsw((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw > *smartresult = result ? new ext::shared_ptr<  Bbsw >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Bbsw *)new Bbsw((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw > *smartresult = result ? new ext::shared_ptr<  Bbsw >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Bbsw__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw::Bbsw(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Bbsw::Bbsw(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw *arg1 = (Bbsw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw > tempshared1 ;
  ext::shared_ptr< Bbsw > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw" "', argument " "1"" of type '" "Bbsw *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw > * >(argp1);
      arg1 = const_cast< Bbsw * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw > * >(argp1);
      arg1 = const_cast< Bbsw * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw1M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw1M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bbsw1M *)new Bbsw1M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw1M > *smartresult = result ? new ext::shared_ptr<  Bbsw1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw1M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bbsw1M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bbsw1M *)new Bbsw1M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw1M > *smartresult = result ? new ext::shared_ptr<  Bbsw1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw1M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw1M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bbsw1M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw1M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw1M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw1M::Bbsw1M(Handle< YieldTermStructure > const &)\n"
    "    Bbsw1M::Bbsw1M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw1M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw1M *arg1 = (Bbsw1M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw1M > tempshared1 ;
  ext::shared_ptr< Bbsw1M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw1M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw1M" "', argument " "1"" of type '" "Bbsw1M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw1M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw1M > * >(argp1);
      arg1 = const_cast< Bbsw1M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw1M > * >(argp1);
      arg1 = const_cast< Bbsw1M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw1M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw1M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw1M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw2M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw2M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bbsw2M *)new Bbsw2M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw2M > *smartresult = result ? new ext::shared_ptr<  Bbsw2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw2M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bbsw2M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bbsw2M *)new Bbsw2M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw2M > *smartresult = result ? new ext::shared_ptr<  Bbsw2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw2M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw2M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bbsw2M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw2M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw2M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw2M::Bbsw2M(Handle< YieldTermStructure > const &)\n"
    "    Bbsw2M::Bbsw2M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw2M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw2M *arg1 = (Bbsw2M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw2M > tempshared1 ;
  ext::shared_ptr< Bbsw2M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw2M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw2M" "', argument " "1"" of type '" "Bbsw2M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw2M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw2M > * >(argp1);
      arg1 = const_cast< Bbsw2M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw2M > * >(argp1);
      arg1 = const_cast< Bbsw2M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw2M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw2M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw2M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw3M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw3M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bbsw3M *)new Bbsw3M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw3M > *smartresult = result ? new ext::shared_ptr<  Bbsw3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw3M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bbsw3M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bbsw3M *)new Bbsw3M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw3M > *smartresult = result ? new ext::shared_ptr<  Bbsw3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw3M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw3M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bbsw3M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw3M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw3M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw3M::Bbsw3M(Handle< YieldTermStructure > const &)\n"
    "    Bbsw3M::Bbsw3M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw3M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw3M *arg1 = (Bbsw3M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw3M > tempshared1 ;
  ext::shared_ptr< Bbsw3M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw3M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw3M" "', argument " "1"" of type '" "Bbsw3M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw3M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw3M > * >(argp1);
      arg1 = const_cast< Bbsw3M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw3M > * >(argp1);
      arg1 = const_cast< Bbsw3M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw3M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw3M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw3M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw4M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw4M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bbsw4M *)new Bbsw4M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw4M > *smartresult = result ? new ext::shared_ptr<  Bbsw4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw4M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bbsw4M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bbsw4M *)new Bbsw4M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw4M > *smartresult = result ? new ext::shared_ptr<  Bbsw4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw4M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw4M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bbsw4M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw4M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw4M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw4M::Bbsw4M(Handle< YieldTermStructure > const &)\n"
    "    Bbsw4M::Bbsw4M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw4M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw4M *arg1 = (Bbsw4M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw4M > tempshared1 ;
  ext::shared_ptr< Bbsw4M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw4M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw4M" "', argument " "1"" of type '" "Bbsw4M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw4M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw4M > * >(argp1);
      arg1 = const_cast< Bbsw4M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw4M > * >(argp1);
      arg1 = const_cast< Bbsw4M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw4M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw4M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw4M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw5M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw5M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bbsw5M *)new Bbsw5M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw5M > *smartresult = result ? new ext::shared_ptr<  Bbsw5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw5M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bbsw5M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bbsw5M *)new Bbsw5M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw5M > *smartresult = result ? new ext::shared_ptr<  Bbsw5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw5M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw5M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bbsw5M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw5M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw5M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw5M::Bbsw5M(Handle< YieldTermStructure > const &)\n"
    "    Bbsw5M::Bbsw5M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw5M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw5M *arg1 = (Bbsw5M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw5M > tempshared1 ;
  ext::shared_ptr< Bbsw5M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw5M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw5M" "', argument " "1"" of type '" "Bbsw5M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw5M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw5M > * >(argp1);
      arg1 = const_cast< Bbsw5M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw5M > * >(argp1);
      arg1 = const_cast< Bbsw5M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw5M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw5M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw5M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bbsw6M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bbsw6M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bbsw6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bbsw6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bbsw6M *)new Bbsw6M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw6M > *smartresult = result ? new ext::shared_ptr<  Bbsw6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw6M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bbsw6M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bbsw6M *)new Bbsw6M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bbsw6M > *smartresult = result ? new ext::shared_ptr<  Bbsw6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bbsw6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bbsw6M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bbsw6M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bbsw6M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bbsw6M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bbsw6M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bbsw6M::Bbsw6M(Handle< YieldTermStructure > const &)\n"
    "    Bbsw6M::Bbsw6M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bbsw6M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bbsw6M *arg1 = (Bbsw6M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bbsw6M > tempshared1 ;
  ext::shared_ptr< Bbsw6M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bbsw6M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bbsw6M" "', argument " "1"" of type '" "Bbsw6M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bbsw6M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bbsw6M > * >(argp1);
      arg1 = const_cast< Bbsw6M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bbsw6M > * >(argp1);
      arg1 = const_cast< Bbsw6M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bbsw6M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bbsw6M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bbsw6M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Bkbm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bkbm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Bkbm *)new Bkbm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm > *smartresult = result ? new ext::shared_ptr<  Bkbm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Bkbm *)new Bkbm((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm > *smartresult = result ? new ext::shared_ptr<  Bkbm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Bkbm__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm::Bkbm(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Bkbm::Bkbm(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm *arg1 = (Bkbm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm > tempshared1 ;
  ext::shared_ptr< Bkbm > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm" "', argument " "1"" of type '" "Bkbm *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm > * >(argp1);
      arg1 = const_cast< Bkbm * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm > * >(argp1);
      arg1 = const_cast< Bkbm * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm1M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm1M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bkbm1M *)new Bkbm1M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm1M > *smartresult = result ? new ext::shared_ptr<  Bkbm1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm1M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bkbm1M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bkbm1M *)new Bkbm1M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm1M > *smartresult = result ? new ext::shared_ptr<  Bkbm1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm1M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm1M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bkbm1M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm1M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm1M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm1M::Bkbm1M(Handle< YieldTermStructure > const &)\n"
    "    Bkbm1M::Bkbm1M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm1M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm1M *arg1 = (Bkbm1M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm1M > tempshared1 ;
  ext::shared_ptr< Bkbm1M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm1M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm1M" "', argument " "1"" of type '" "Bkbm1M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm1M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm1M > * >(argp1);
      arg1 = const_cast< Bkbm1M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm1M > * >(argp1);
      arg1 = const_cast< Bkbm1M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm1M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm1M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm1M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm2M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm2M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bkbm2M *)new Bkbm2M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm2M > *smartresult = result ? new ext::shared_ptr<  Bkbm2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm2M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bkbm2M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bkbm2M *)new Bkbm2M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm2M > *smartresult = result ? new ext::shared_ptr<  Bkbm2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm2M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm2M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bkbm2M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm2M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm2M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm2M::Bkbm2M(Handle< YieldTermStructure > const &)\n"
    "    Bkbm2M::Bkbm2M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm2M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm2M *arg1 = (Bkbm2M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm2M > tempshared1 ;
  ext::shared_ptr< Bkbm2M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm2M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm2M" "', argument " "1"" of type '" "Bkbm2M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm2M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm2M > * >(argp1);
      arg1 = const_cast< Bkbm2M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm2M > * >(argp1);
      arg1 = const_cast< Bkbm2M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm2M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm2M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm2M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm3M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm3M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bkbm3M *)new Bkbm3M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm3M > *smartresult = result ? new ext::shared_ptr<  Bkbm3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm3M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bkbm3M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bkbm3M *)new Bkbm3M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm3M > *smartresult = result ? new ext::shared_ptr<  Bkbm3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm3M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm3M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bkbm3M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm3M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm3M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm3M::Bkbm3M(Handle< YieldTermStructure > const &)\n"
    "    Bkbm3M::Bkbm3M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm3M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm3M *arg1 = (Bkbm3M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm3M > tempshared1 ;
  ext::shared_ptr< Bkbm3M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm3M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm3M" "', argument " "1"" of type '" "Bkbm3M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm3M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm3M > * >(argp1);
      arg1 = const_cast< Bkbm3M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm3M > * >(argp1);
      arg1 = const_cast< Bkbm3M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm3M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm3M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm3M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm4M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm4M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bkbm4M *)new Bkbm4M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm4M > *smartresult = result ? new ext::shared_ptr<  Bkbm4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm4M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bkbm4M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bkbm4M *)new Bkbm4M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm4M > *smartresult = result ? new ext::shared_ptr<  Bkbm4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm4M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm4M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bkbm4M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm4M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm4M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm4M::Bkbm4M(Handle< YieldTermStructure > const &)\n"
    "    Bkbm4M::Bkbm4M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm4M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm4M *arg1 = (Bkbm4M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm4M > tempshared1 ;
  ext::shared_ptr< Bkbm4M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm4M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm4M" "', argument " "1"" of type '" "Bkbm4M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm4M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm4M > * >(argp1);
      arg1 = const_cast< Bkbm4M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm4M > * >(argp1);
      arg1 = const_cast< Bkbm4M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm4M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm4M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm4M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm5M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm5M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bkbm5M *)new Bkbm5M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm5M > *smartresult = result ? new ext::shared_ptr<  Bkbm5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm5M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bkbm5M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bkbm5M *)new Bkbm5M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm5M > *smartresult = result ? new ext::shared_ptr<  Bkbm5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm5M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm5M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bkbm5M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm5M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm5M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm5M::Bkbm5M(Handle< YieldTermStructure > const &)\n"
    "    Bkbm5M::Bkbm5M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm5M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm5M *arg1 = (Bkbm5M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm5M > tempshared1 ;
  ext::shared_ptr< Bkbm5M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm5M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm5M" "', argument " "1"" of type '" "Bkbm5M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm5M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm5M > * >(argp1);
      arg1 = const_cast< Bkbm5M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm5M > * >(argp1);
      arg1 = const_cast< Bkbm5M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm5M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm5M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm5M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bkbm6M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bkbm6M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bkbm6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bkbm6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bkbm6M *)new Bkbm6M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm6M > *smartresult = result ? new ext::shared_ptr<  Bkbm6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm6M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bkbm6M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bkbm6M *)new Bkbm6M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bkbm6M > *smartresult = result ? new ext::shared_ptr<  Bkbm6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bkbm6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bkbm6M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bkbm6M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bkbm6M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bkbm6M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bkbm6M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bkbm6M::Bkbm6M(Handle< YieldTermStructure > const &)\n"
    "    Bkbm6M::Bkbm6M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bkbm6M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bkbm6M *arg1 = (Bkbm6M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bkbm6M > tempshared1 ;
  ext::shared_ptr< Bkbm6M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bkbm6M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bkbm6M" "', argument " "1"" of type '" "Bkbm6M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bkbm6M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bkbm6M > * >(argp1);
      arg1 = const_cast< Bkbm6M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bkbm6M > * >(argp1);
      arg1 = const_cast< Bkbm6M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bkbm6M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bkbm6M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bkbm6M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Euribor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Euribor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Euribor *)new Euribor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor > *smartresult = result ? new ext::shared_ptr<  Euribor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Euribor *)new Euribor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor > *smartresult = result ? new ext::shared_ptr<  Euribor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Euribor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor::Euribor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Euribor::Euribor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor *arg1 = (Euribor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor > tempshared1 ;
  ext::shared_ptr< Euribor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor" "', argument " "1"" of type '" "Euribor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor > * >(argp1);
      arg1 = const_cast< Euribor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor > * >(argp1);
      arg1 = const_cast< Euribor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EuriborSW__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EuriborSW *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EuriborSW *)new EuriborSW((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSW > *smartresult = result ? new ext::shared_ptr<  EuriborSW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSW__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EuriborSW *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EuriborSW *)new EuriborSW();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSW > *smartresult = result ? new ext::shared_ptr<  EuriborSW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSW(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EuriborSW", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EuriborSW__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EuriborSW__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EuriborSW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EuriborSW::EuriborSW(Handle< YieldTermStructure > const &)\n"
    "    EuriborSW::EuriborSW()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EuriborSW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EuriborSW *arg1 = (EuriborSW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EuriborSW > tempshared1 ;
  ext::shared_ptr< EuriborSW > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EuriborSW_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EuriborSW" "', argument " "1"" of type '" "EuriborSW *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EuriborSW > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EuriborSW > * >(argp1);
      arg1 = const_cast< EuriborSW * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EuriborSW > * >(argp1);
      arg1 = const_cast< EuriborSW * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EuriborSW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EuriborSW_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EuriborSW_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor2W__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor2W *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor2W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor2W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor2W *)new Euribor2W((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor2W > *smartresult = result ? new ext::shared_ptr<  Euribor2W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor2W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor2W__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor2W *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor2W *)new Euribor2W();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor2W > *smartresult = result ? new ext::shared_ptr<  Euribor2W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor2W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor2W(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor2W", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor2W__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor2W__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor2W'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor2W::Euribor2W(Handle< YieldTermStructure > const &)\n"
    "    Euribor2W::Euribor2W()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor2W(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor2W *arg1 = (Euribor2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor2W > tempshared1 ;
  ext::shared_ptr< Euribor2W > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor2W_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor2W" "', argument " "1"" of type '" "Euribor2W *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor2W > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor2W > * >(argp1);
      arg1 = const_cast< Euribor2W * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor2W > * >(argp1);
      arg1 = const_cast< Euribor2W * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor2W_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor2W_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor2W_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor3W__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor3W *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor3W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor3W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor3W *)new Euribor3W((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor3W > *smartresult = result ? new ext::shared_ptr<  Euribor3W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor3W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor3W__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor3W *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor3W *)new Euribor3W();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor3W > *smartresult = result ? new ext::shared_ptr<  Euribor3W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor3W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor3W(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor3W", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor3W__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor3W__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor3W'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor3W::Euribor3W(Handle< YieldTermStructure > const &)\n"
    "    Euribor3W::Euribor3W()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor3W(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor3W *arg1 = (Euribor3W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor3W > tempshared1 ;
  ext::shared_ptr< Euribor3W > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor3W_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor3W" "', argument " "1"" of type '" "Euribor3W *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor3W > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor3W > * >(argp1);
      arg1 = const_cast< Euribor3W * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor3W > * >(argp1);
      arg1 = const_cast< Euribor3W * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor3W_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor3W_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor3W_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor1M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor1M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor1M *)new Euribor1M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor1M > *smartresult = result ? new ext::shared_ptr<  Euribor1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor1M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor1M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor1M *)new Euribor1M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor1M > *smartresult = result ? new ext::shared_ptr<  Euribor1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor1M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor1M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor1M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor1M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor1M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor1M::Euribor1M(Handle< YieldTermStructure > const &)\n"
    "    Euribor1M::Euribor1M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor1M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor1M *arg1 = (Euribor1M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor1M > tempshared1 ;
  ext::shared_ptr< Euribor1M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor1M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor1M" "', argument " "1"" of type '" "Euribor1M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor1M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor1M > * >(argp1);
      arg1 = const_cast< Euribor1M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor1M > * >(argp1);
      arg1 = const_cast< Euribor1M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor1M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor1M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor1M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor2M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor2M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor2M *)new Euribor2M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor2M > *smartresult = result ? new ext::shared_ptr<  Euribor2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor2M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor2M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor2M *)new Euribor2M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor2M > *smartresult = result ? new ext::shared_ptr<  Euribor2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor2M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor2M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor2M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor2M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor2M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor2M::Euribor2M(Handle< YieldTermStructure > const &)\n"
    "    Euribor2M::Euribor2M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor2M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor2M *arg1 = (Euribor2M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor2M > tempshared1 ;
  ext::shared_ptr< Euribor2M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor2M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor2M" "', argument " "1"" of type '" "Euribor2M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor2M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor2M > * >(argp1);
      arg1 = const_cast< Euribor2M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor2M > * >(argp1);
      arg1 = const_cast< Euribor2M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor2M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor2M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor2M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor3M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor3M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor3M *)new Euribor3M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor3M > *smartresult = result ? new ext::shared_ptr<  Euribor3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor3M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor3M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor3M *)new Euribor3M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor3M > *smartresult = result ? new ext::shared_ptr<  Euribor3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor3M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor3M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor3M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor3M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor3M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor3M::Euribor3M(Handle< YieldTermStructure > const &)\n"
    "    Euribor3M::Euribor3M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor3M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor3M *arg1 = (Euribor3M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor3M > tempshared1 ;
  ext::shared_ptr< Euribor3M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor3M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor3M" "', argument " "1"" of type '" "Euribor3M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor3M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor3M > * >(argp1);
      arg1 = const_cast< Euribor3M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor3M > * >(argp1);
      arg1 = const_cast< Euribor3M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor3M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor3M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor3M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor4M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor4M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor4M *)new Euribor4M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor4M > *smartresult = result ? new ext::shared_ptr<  Euribor4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor4M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor4M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor4M *)new Euribor4M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor4M > *smartresult = result ? new ext::shared_ptr<  Euribor4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor4M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor4M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor4M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor4M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor4M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor4M::Euribor4M(Handle< YieldTermStructure > const &)\n"
    "    Euribor4M::Euribor4M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor4M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor4M *arg1 = (Euribor4M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor4M > tempshared1 ;
  ext::shared_ptr< Euribor4M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor4M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor4M" "', argument " "1"" of type '" "Euribor4M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor4M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor4M > * >(argp1);
      arg1 = const_cast< Euribor4M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor4M > * >(argp1);
      arg1 = const_cast< Euribor4M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor4M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor4M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor4M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor5M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor5M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor5M *)new Euribor5M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor5M > *smartresult = result ? new ext::shared_ptr<  Euribor5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor5M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor5M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor5M *)new Euribor5M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor5M > *smartresult = result ? new ext::shared_ptr<  Euribor5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor5M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor5M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor5M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor5M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor5M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor5M::Euribor5M(Handle< YieldTermStructure > const &)\n"
    "    Euribor5M::Euribor5M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor5M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor5M *arg1 = (Euribor5M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor5M > tempshared1 ;
  ext::shared_ptr< Euribor5M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor5M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor5M" "', argument " "1"" of type '" "Euribor5M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor5M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor5M > * >(argp1);
      arg1 = const_cast< Euribor5M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor5M > * >(argp1);
      arg1 = const_cast< Euribor5M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor5M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor5M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor5M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor6M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor6M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor6M *)new Euribor6M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor6M > *smartresult = result ? new ext::shared_ptr<  Euribor6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor6M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor6M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor6M *)new Euribor6M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor6M > *smartresult = result ? new ext::shared_ptr<  Euribor6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor6M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor6M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor6M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor6M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor6M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor6M::Euribor6M(Handle< YieldTermStructure > const &)\n"
    "    Euribor6M::Euribor6M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor6M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor6M *arg1 = (Euribor6M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor6M > tempshared1 ;
  ext::shared_ptr< Euribor6M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor6M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor6M" "', argument " "1"" of type '" "Euribor6M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor6M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor6M > * >(argp1);
      arg1 = const_cast< Euribor6M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor6M > * >(argp1);
      arg1 = const_cast< Euribor6M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor6M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor6M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor6M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor7M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor7M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor7M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor7M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor7M *)new Euribor7M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor7M > *smartresult = result ? new ext::shared_ptr<  Euribor7M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor7M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor7M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor7M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor7M *)new Euribor7M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor7M > *smartresult = result ? new ext::shared_ptr<  Euribor7M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor7M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor7M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor7M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor7M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor7M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor7M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor7M::Euribor7M(Handle< YieldTermStructure > const &)\n"
    "    Euribor7M::Euribor7M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor7M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor7M *arg1 = (Euribor7M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor7M > tempshared1 ;
  ext::shared_ptr< Euribor7M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor7M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor7M" "', argument " "1"" of type '" "Euribor7M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor7M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor7M > * >(argp1);
      arg1 = const_cast< Euribor7M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor7M > * >(argp1);
      arg1 = const_cast< Euribor7M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor7M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor7M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor7M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor8M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor8M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor8M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor8M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor8M *)new Euribor8M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor8M > *smartresult = result ? new ext::shared_ptr<  Euribor8M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor8M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor8M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor8M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor8M *)new Euribor8M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor8M > *smartresult = result ? new ext::shared_ptr<  Euribor8M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor8M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor8M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor8M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor8M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor8M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor8M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor8M::Euribor8M(Handle< YieldTermStructure > const &)\n"
    "    Euribor8M::Euribor8M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor8M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor8M *arg1 = (Euribor8M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor8M > tempshared1 ;
  ext::shared_ptr< Euribor8M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor8M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor8M" "', argument " "1"" of type '" "Euribor8M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor8M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor8M > * >(argp1);
      arg1 = const_cast< Euribor8M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor8M > * >(argp1);
      arg1 = const_cast< Euribor8M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor8M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor8M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor8M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor9M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor9M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor9M *)new Euribor9M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor9M > *smartresult = result ? new ext::shared_ptr<  Euribor9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor9M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor9M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor9M *)new Euribor9M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor9M > *smartresult = result ? new ext::shared_ptr<  Euribor9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor9M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor9M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor9M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor9M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor9M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor9M::Euribor9M(Handle< YieldTermStructure > const &)\n"
    "    Euribor9M::Euribor9M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor9M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor9M *arg1 = (Euribor9M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor9M > tempshared1 ;
  ext::shared_ptr< Euribor9M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor9M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor9M" "', argument " "1"" of type '" "Euribor9M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor9M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor9M > * >(argp1);
      arg1 = const_cast< Euribor9M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor9M > * >(argp1);
      arg1 = const_cast< Euribor9M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor9M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor9M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor9M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor10M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor10M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor10M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor10M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor10M *)new Euribor10M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor10M > *smartresult = result ? new ext::shared_ptr<  Euribor10M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor10M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor10M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor10M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor10M *)new Euribor10M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor10M > *smartresult = result ? new ext::shared_ptr<  Euribor10M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor10M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor10M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor10M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor10M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor10M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor10M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor10M::Euribor10M(Handle< YieldTermStructure > const &)\n"
    "    Euribor10M::Euribor10M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor10M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor10M *arg1 = (Euribor10M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor10M > tempshared1 ;
  ext::shared_ptr< Euribor10M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor10M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor10M" "', argument " "1"" of type '" "Euribor10M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor10M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor10M > * >(argp1);
      arg1 = const_cast< Euribor10M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor10M > * >(argp1);
      arg1 = const_cast< Euribor10M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor10M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor10M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor10M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor11M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor11M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor11M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor11M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor11M *)new Euribor11M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor11M > *smartresult = result ? new ext::shared_ptr<  Euribor11M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor11M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor11M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor11M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor11M *)new Euribor11M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor11M > *smartresult = result ? new ext::shared_ptr<  Euribor11M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor11M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor11M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor11M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor11M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor11M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor11M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor11M::Euribor11M(Handle< YieldTermStructure > const &)\n"
    "    Euribor11M::Euribor11M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor11M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor11M *arg1 = (Euribor11M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor11M > tempshared1 ;
  ext::shared_ptr< Euribor11M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor11M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor11M" "', argument " "1"" of type '" "Euribor11M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor11M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor11M > * >(argp1);
      arg1 = const_cast< Euribor11M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor11M > * >(argp1);
      arg1 = const_cast< Euribor11M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor11M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor11M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor11M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor1Y__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor1Y *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor1Y *)new Euribor1Y((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor1Y > *smartresult = result ? new ext::shared_ptr<  Euribor1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor1Y__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor1Y *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor1Y *)new Euribor1Y();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor1Y > *smartresult = result ? new ext::shared_ptr<  Euribor1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor1Y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor1Y", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor1Y__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor1Y__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor1Y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor1Y::Euribor1Y(Handle< YieldTermStructure > const &)\n"
    "    Euribor1Y::Euribor1Y()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor1Y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor1Y *arg1 = (Euribor1Y *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor1Y > tempshared1 ;
  ext::shared_ptr< Euribor1Y > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor1Y_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor1Y" "', argument " "1"" of type '" "Euribor1Y *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor1Y > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor1Y > * >(argp1);
      arg1 = const_cast< Euribor1Y * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor1Y > * >(argp1);
      arg1 = const_cast< Euribor1Y * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor1Y_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor1Y_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor1Y_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Euribor365 *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Euribor365" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Euribor365 *)new Euribor365((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365 > *smartresult = result ? new ext::shared_ptr<  Euribor365 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Euribor365 *)new Euribor365((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365 > *smartresult = result ? new ext::shared_ptr<  Euribor365 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Euribor365__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365::Euribor365(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Euribor365::Euribor365(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365 *arg1 = (Euribor365 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365 > tempshared1 ;
  ext::shared_ptr< Euribor365 > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365" "', argument " "1"" of type '" "Euribor365 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365 > * >(argp1);
      arg1 = const_cast< Euribor365 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365 > * >(argp1);
      arg1 = const_cast< Euribor365 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_SW__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_SW *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_SW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_SW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_SW *)new Euribor365_SW((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_SW > *smartresult = result ? new ext::shared_ptr<  Euribor365_SW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_SW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_SW__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_SW *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_SW *)new Euribor365_SW();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_SW > *smartresult = result ? new ext::shared_ptr<  Euribor365_SW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_SW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_SW(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_SW", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_SW__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_SW__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_SW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_SW::Euribor365_SW(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_SW::Euribor365_SW()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_SW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_SW *arg1 = (Euribor365_SW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_SW > tempshared1 ;
  ext::shared_ptr< Euribor365_SW > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_SW_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_SW" "', argument " "1"" of type '" "Euribor365_SW *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_SW > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_SW > * >(argp1);
      arg1 = const_cast< Euribor365_SW * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_SW > * >(argp1);
      arg1 = const_cast< Euribor365_SW * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_SW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_SW_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_SW_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_2W__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_2W *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_2W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_2W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_2W *)new Euribor365_2W((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_2W > *smartresult = result ? new ext::shared_ptr<  Euribor365_2W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_2W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_2W__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_2W *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_2W *)new Euribor365_2W();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_2W > *smartresult = result ? new ext::shared_ptr<  Euribor365_2W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_2W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_2W(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_2W", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_2W__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_2W__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_2W'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_2W::Euribor365_2W(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_2W::Euribor365_2W()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_2W(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_2W *arg1 = (Euribor365_2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_2W > tempshared1 ;
  ext::shared_ptr< Euribor365_2W > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_2W_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_2W" "', argument " "1"" of type '" "Euribor365_2W *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_2W > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_2W > * >(argp1);
      arg1 = const_cast< Euribor365_2W * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_2W > * >(argp1);
      arg1 = const_cast< Euribor365_2W * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_2W_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_2W_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_2W_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_3W__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_3W *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_3W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_3W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_3W *)new Euribor365_3W((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_3W > *smartresult = result ? new ext::shared_ptr<  Euribor365_3W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_3W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_3W__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_3W *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_3W *)new Euribor365_3W();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_3W > *smartresult = result ? new ext::shared_ptr<  Euribor365_3W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_3W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_3W(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_3W", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_3W__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_3W__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_3W'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_3W::Euribor365_3W(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_3W::Euribor365_3W()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_3W(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_3W *arg1 = (Euribor365_3W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_3W > tempshared1 ;
  ext::shared_ptr< Euribor365_3W > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_3W_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_3W" "', argument " "1"" of type '" "Euribor365_3W *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_3W > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_3W > * >(argp1);
      arg1 = const_cast< Euribor365_3W * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_3W > * >(argp1);
      arg1 = const_cast< Euribor365_3W * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_3W_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_3W_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_3W_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_1M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_1M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_1M *)new Euribor365_1M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_1M > *smartresult = result ? new ext::shared_ptr<  Euribor365_1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_1M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_1M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_1M *)new Euribor365_1M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_1M > *smartresult = result ? new ext::shared_ptr<  Euribor365_1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_1M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_1M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_1M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_1M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_1M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_1M::Euribor365_1M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_1M::Euribor365_1M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_1M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_1M *arg1 = (Euribor365_1M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_1M > tempshared1 ;
  ext::shared_ptr< Euribor365_1M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_1M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_1M" "', argument " "1"" of type '" "Euribor365_1M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_1M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_1M > * >(argp1);
      arg1 = const_cast< Euribor365_1M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_1M > * >(argp1);
      arg1 = const_cast< Euribor365_1M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_1M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_1M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_1M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_2M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_2M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_2M *)new Euribor365_2M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_2M > *smartresult = result ? new ext::shared_ptr<  Euribor365_2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_2M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_2M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_2M *)new Euribor365_2M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_2M > *smartresult = result ? new ext::shared_ptr<  Euribor365_2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_2M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_2M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_2M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_2M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_2M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_2M::Euribor365_2M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_2M::Euribor365_2M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_2M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_2M *arg1 = (Euribor365_2M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_2M > tempshared1 ;
  ext::shared_ptr< Euribor365_2M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_2M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_2M" "', argument " "1"" of type '" "Euribor365_2M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_2M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_2M > * >(argp1);
      arg1 = const_cast< Euribor365_2M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_2M > * >(argp1);
      arg1 = const_cast< Euribor365_2M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_2M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_2M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_2M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_3M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_3M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_3M *)new Euribor365_3M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_3M > *smartresult = result ? new ext::shared_ptr<  Euribor365_3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_3M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_3M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_3M *)new Euribor365_3M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_3M > *smartresult = result ? new ext::shared_ptr<  Euribor365_3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_3M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_3M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_3M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_3M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_3M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_3M::Euribor365_3M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_3M::Euribor365_3M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_3M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_3M *arg1 = (Euribor365_3M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_3M > tempshared1 ;
  ext::shared_ptr< Euribor365_3M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_3M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_3M" "', argument " "1"" of type '" "Euribor365_3M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_3M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_3M > * >(argp1);
      arg1 = const_cast< Euribor365_3M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_3M > * >(argp1);
      arg1 = const_cast< Euribor365_3M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_3M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_3M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_3M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_4M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_4M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_4M *)new Euribor365_4M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_4M > *smartresult = result ? new ext::shared_ptr<  Euribor365_4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_4M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_4M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_4M *)new Euribor365_4M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_4M > *smartresult = result ? new ext::shared_ptr<  Euribor365_4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_4M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_4M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_4M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_4M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_4M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_4M::Euribor365_4M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_4M::Euribor365_4M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_4M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_4M *arg1 = (Euribor365_4M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_4M > tempshared1 ;
  ext::shared_ptr< Euribor365_4M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_4M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_4M" "', argument " "1"" of type '" "Euribor365_4M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_4M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_4M > * >(argp1);
      arg1 = const_cast< Euribor365_4M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_4M > * >(argp1);
      arg1 = const_cast< Euribor365_4M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_4M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_4M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_4M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_5M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_5M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_5M *)new Euribor365_5M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_5M > *smartresult = result ? new ext::shared_ptr<  Euribor365_5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_5M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_5M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_5M *)new Euribor365_5M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_5M > *smartresult = result ? new ext::shared_ptr<  Euribor365_5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_5M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_5M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_5M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_5M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_5M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_5M::Euribor365_5M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_5M::Euribor365_5M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_5M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_5M *arg1 = (Euribor365_5M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_5M > tempshared1 ;
  ext::shared_ptr< Euribor365_5M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_5M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_5M" "', argument " "1"" of type '" "Euribor365_5M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_5M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_5M > * >(argp1);
      arg1 = const_cast< Euribor365_5M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_5M > * >(argp1);
      arg1 = const_cast< Euribor365_5M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_5M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_5M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_5M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_6M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_6M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_6M *)new Euribor365_6M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_6M > *smartresult = result ? new ext::shared_ptr<  Euribor365_6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_6M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_6M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_6M *)new Euribor365_6M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_6M > *smartresult = result ? new ext::shared_ptr<  Euribor365_6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_6M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_6M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_6M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_6M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_6M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_6M::Euribor365_6M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_6M::Euribor365_6M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_6M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_6M *arg1 = (Euribor365_6M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_6M > tempshared1 ;
  ext::shared_ptr< Euribor365_6M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_6M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_6M" "', argument " "1"" of type '" "Euribor365_6M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_6M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_6M > * >(argp1);
      arg1 = const_cast< Euribor365_6M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_6M > * >(argp1);
      arg1 = const_cast< Euribor365_6M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_6M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_6M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_6M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_7M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_7M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_7M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_7M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_7M *)new Euribor365_7M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_7M > *smartresult = result ? new ext::shared_ptr<  Euribor365_7M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_7M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_7M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_7M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_7M *)new Euribor365_7M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_7M > *smartresult = result ? new ext::shared_ptr<  Euribor365_7M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_7M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_7M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_7M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_7M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_7M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_7M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_7M::Euribor365_7M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_7M::Euribor365_7M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_7M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_7M *arg1 = (Euribor365_7M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_7M > tempshared1 ;
  ext::shared_ptr< Euribor365_7M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_7M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_7M" "', argument " "1"" of type '" "Euribor365_7M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_7M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_7M > * >(argp1);
      arg1 = const_cast< Euribor365_7M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_7M > * >(argp1);
      arg1 = const_cast< Euribor365_7M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_7M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_7M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_7M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_8M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_8M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_8M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_8M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_8M *)new Euribor365_8M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_8M > *smartresult = result ? new ext::shared_ptr<  Euribor365_8M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_8M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_8M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_8M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_8M *)new Euribor365_8M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_8M > *smartresult = result ? new ext::shared_ptr<  Euribor365_8M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_8M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_8M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_8M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_8M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_8M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_8M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_8M::Euribor365_8M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_8M::Euribor365_8M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_8M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_8M *arg1 = (Euribor365_8M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_8M > tempshared1 ;
  ext::shared_ptr< Euribor365_8M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_8M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_8M" "', argument " "1"" of type '" "Euribor365_8M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_8M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_8M > * >(argp1);
      arg1 = const_cast< Euribor365_8M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_8M > * >(argp1);
      arg1 = const_cast< Euribor365_8M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_8M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_8M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_8M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_9M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_9M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_9M *)new Euribor365_9M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_9M > *smartresult = result ? new ext::shared_ptr<  Euribor365_9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_9M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_9M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_9M *)new Euribor365_9M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_9M > *smartresult = result ? new ext::shared_ptr<  Euribor365_9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_9M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_9M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_9M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_9M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_9M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_9M::Euribor365_9M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_9M::Euribor365_9M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_9M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_9M *arg1 = (Euribor365_9M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_9M > tempshared1 ;
  ext::shared_ptr< Euribor365_9M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_9M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_9M" "', argument " "1"" of type '" "Euribor365_9M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_9M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_9M > * >(argp1);
      arg1 = const_cast< Euribor365_9M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_9M > * >(argp1);
      arg1 = const_cast< Euribor365_9M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_9M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_9M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_9M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_10M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_10M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_10M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_10M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_10M *)new Euribor365_10M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_10M > *smartresult = result ? new ext::shared_ptr<  Euribor365_10M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_10M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_10M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_10M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_10M *)new Euribor365_10M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_10M > *smartresult = result ? new ext::shared_ptr<  Euribor365_10M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_10M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_10M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_10M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_10M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_10M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_10M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_10M::Euribor365_10M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_10M::Euribor365_10M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_10M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_10M *arg1 = (Euribor365_10M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_10M > tempshared1 ;
  ext::shared_ptr< Euribor365_10M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_10M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_10M" "', argument " "1"" of type '" "Euribor365_10M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_10M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_10M > * >(argp1);
      arg1 = const_cast< Euribor365_10M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_10M > * >(argp1);
      arg1 = const_cast< Euribor365_10M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_10M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_10M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_10M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_11M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_11M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_11M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_11M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_11M *)new Euribor365_11M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_11M > *smartresult = result ? new ext::shared_ptr<  Euribor365_11M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_11M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_11M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_11M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_11M *)new Euribor365_11M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_11M > *smartresult = result ? new ext::shared_ptr<  Euribor365_11M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_11M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_11M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_11M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_11M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_11M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_11M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_11M::Euribor365_11M(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_11M::Euribor365_11M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_11M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_11M *arg1 = (Euribor365_11M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_11M > tempshared1 ;
  ext::shared_ptr< Euribor365_11M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_11M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_11M" "', argument " "1"" of type '" "Euribor365_11M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_11M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_11M > * >(argp1);
      arg1 = const_cast< Euribor365_11M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_11M > * >(argp1);
      arg1 = const_cast< Euribor365_11M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_11M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_11M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_11M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Euribor365_1Y__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Euribor365_1Y *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Euribor365_1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Euribor365_1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Euribor365_1Y *)new Euribor365_1Y((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_1Y > *smartresult = result ? new ext::shared_ptr<  Euribor365_1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_1Y__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Euribor365_1Y *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Euribor365_1Y *)new Euribor365_1Y();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Euribor365_1Y > *smartresult = result ? new ext::shared_ptr<  Euribor365_1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Euribor365_1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Euribor365_1Y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Euribor365_1Y", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Euribor365_1Y__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Euribor365_1Y__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Euribor365_1Y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Euribor365_1Y::Euribor365_1Y(Handle< YieldTermStructure > const &)\n"
    "    Euribor365_1Y::Euribor365_1Y()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Euribor365_1Y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Euribor365_1Y *arg1 = (Euribor365_1Y *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Euribor365_1Y > tempshared1 ;
  ext::shared_ptr< Euribor365_1Y > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Euribor365_1Y_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Euribor365_1Y" "', argument " "1"" of type '" "Euribor365_1Y *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Euribor365_1Y > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Euribor365_1Y > * >(argp1);
      arg1 = const_cast< Euribor365_1Y * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Euribor365_1Y > * >(argp1);
      arg1 = const_cast< Euribor365_1Y * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Euribor365_1Y_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Euribor365_1Y_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Euribor365_1Y_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EURLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EURLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EURLibor *)new EURLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor > *smartresult = result ? new ext::shared_ptr<  EURLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EURLibor *)new EURLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor > *smartresult = result ? new ext::shared_ptr<  EURLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EURLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor::EURLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EURLibor::EURLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor *arg1 = (EURLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor > tempshared1 ;
  ext::shared_ptr< EURLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor" "', argument " "1"" of type '" "EURLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor > * >(argp1);
      arg1 = const_cast< EURLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor > * >(argp1);
      arg1 = const_cast< EURLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLiborSW__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLiborSW *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLiborSW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLiborSW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLiborSW *)new EURLiborSW((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLiborSW > *smartresult = result ? new ext::shared_ptr<  EURLiborSW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLiborSW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLiborSW__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLiborSW *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLiborSW *)new EURLiborSW();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLiborSW > *smartresult = result ? new ext::shared_ptr<  EURLiborSW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLiborSW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLiborSW(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLiborSW", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLiborSW__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLiborSW__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLiborSW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLiborSW::EURLiborSW(Handle< YieldTermStructure > const &)\n"
    "    EURLiborSW::EURLiborSW()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLiborSW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLiborSW *arg1 = (EURLiborSW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLiborSW > tempshared1 ;
  ext::shared_ptr< EURLiborSW > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLiborSW_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLiborSW" "', argument " "1"" of type '" "EURLiborSW *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLiborSW > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLiborSW > * >(argp1);
      arg1 = const_cast< EURLiborSW * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLiborSW > * >(argp1);
      arg1 = const_cast< EURLiborSW * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLiborSW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLiborSW_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLiborSW_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor2W__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor2W *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor2W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor2W" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor2W *)new EURLibor2W((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor2W > *smartresult = result ? new ext::shared_ptr<  EURLibor2W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor2W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor2W__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor2W *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor2W *)new EURLibor2W();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor2W > *smartresult = result ? new ext::shared_ptr<  EURLibor2W >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor2W_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor2W(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor2W", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor2W__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor2W__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor2W'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor2W::EURLibor2W(Handle< YieldTermStructure > const &)\n"
    "    EURLibor2W::EURLibor2W()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor2W(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor2W *arg1 = (EURLibor2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor2W > tempshared1 ;
  ext::shared_ptr< EURLibor2W > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor2W_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor2W" "', argument " "1"" of type '" "EURLibor2W *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor2W > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor2W > * >(argp1);
      arg1 = const_cast< EURLibor2W * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor2W > * >(argp1);
      arg1 = const_cast< EURLibor2W * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor2W_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor2W_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor2W_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor1M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor1M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor1M *)new EURLibor1M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor1M > *smartresult = result ? new ext::shared_ptr<  EURLibor1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor1M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor1M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor1M *)new EURLibor1M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor1M > *smartresult = result ? new ext::shared_ptr<  EURLibor1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor1M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor1M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor1M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor1M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor1M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor1M::EURLibor1M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor1M::EURLibor1M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor1M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor1M *arg1 = (EURLibor1M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor1M > tempshared1 ;
  ext::shared_ptr< EURLibor1M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor1M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor1M" "', argument " "1"" of type '" "EURLibor1M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor1M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor1M > * >(argp1);
      arg1 = const_cast< EURLibor1M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor1M > * >(argp1);
      arg1 = const_cast< EURLibor1M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor1M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor1M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor1M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor2M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor2M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor2M *)new EURLibor2M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor2M > *smartresult = result ? new ext::shared_ptr<  EURLibor2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor2M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor2M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor2M *)new EURLibor2M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor2M > *smartresult = result ? new ext::shared_ptr<  EURLibor2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor2M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor2M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor2M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor2M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor2M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor2M::EURLibor2M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor2M::EURLibor2M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor2M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor2M *arg1 = (EURLibor2M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor2M > tempshared1 ;
  ext::shared_ptr< EURLibor2M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor2M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor2M" "', argument " "1"" of type '" "EURLibor2M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor2M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor2M > * >(argp1);
      arg1 = const_cast< EURLibor2M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor2M > * >(argp1);
      arg1 = const_cast< EURLibor2M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor2M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor2M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor2M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor3M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor3M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor3M *)new EURLibor3M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor3M > *smartresult = result ? new ext::shared_ptr<  EURLibor3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor3M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor3M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor3M *)new EURLibor3M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor3M > *smartresult = result ? new ext::shared_ptr<  EURLibor3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor3M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor3M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor3M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor3M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor3M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor3M::EURLibor3M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor3M::EURLibor3M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor3M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor3M *arg1 = (EURLibor3M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor3M > tempshared1 ;
  ext::shared_ptr< EURLibor3M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor3M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor3M" "', argument " "1"" of type '" "EURLibor3M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor3M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor3M > * >(argp1);
      arg1 = const_cast< EURLibor3M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor3M > * >(argp1);
      arg1 = const_cast< EURLibor3M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor3M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor3M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor3M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor4M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor4M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor4M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor4M *)new EURLibor4M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor4M > *smartresult = result ? new ext::shared_ptr<  EURLibor4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor4M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor4M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor4M *)new EURLibor4M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor4M > *smartresult = result ? new ext::shared_ptr<  EURLibor4M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor4M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor4M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor4M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor4M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor4M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor4M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor4M::EURLibor4M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor4M::EURLibor4M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor4M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor4M *arg1 = (EURLibor4M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor4M > tempshared1 ;
  ext::shared_ptr< EURLibor4M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor4M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor4M" "', argument " "1"" of type '" "EURLibor4M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor4M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor4M > * >(argp1);
      arg1 = const_cast< EURLibor4M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor4M > * >(argp1);
      arg1 = const_cast< EURLibor4M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor4M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor4M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor4M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor5M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor5M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor5M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor5M *)new EURLibor5M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor5M > *smartresult = result ? new ext::shared_ptr<  EURLibor5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor5M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor5M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor5M *)new EURLibor5M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor5M > *smartresult = result ? new ext::shared_ptr<  EURLibor5M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor5M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor5M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor5M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor5M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor5M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor5M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor5M::EURLibor5M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor5M::EURLibor5M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor5M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor5M *arg1 = (EURLibor5M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor5M > tempshared1 ;
  ext::shared_ptr< EURLibor5M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor5M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor5M" "', argument " "1"" of type '" "EURLibor5M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor5M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor5M > * >(argp1);
      arg1 = const_cast< EURLibor5M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor5M > * >(argp1);
      arg1 = const_cast< EURLibor5M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor5M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor5M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor5M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor6M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor6M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor6M *)new EURLibor6M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor6M > *smartresult = result ? new ext::shared_ptr<  EURLibor6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor6M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor6M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor6M *)new EURLibor6M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor6M > *smartresult = result ? new ext::shared_ptr<  EURLibor6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor6M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor6M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor6M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor6M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor6M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor6M::EURLibor6M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor6M::EURLibor6M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor6M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor6M *arg1 = (EURLibor6M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor6M > tempshared1 ;
  ext::shared_ptr< EURLibor6M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor6M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor6M" "', argument " "1"" of type '" "EURLibor6M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor6M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor6M > * >(argp1);
      arg1 = const_cast< EURLibor6M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor6M > * >(argp1);
      arg1 = const_cast< EURLibor6M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor6M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor6M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor6M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor7M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor7M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor7M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor7M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor7M *)new EURLibor7M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor7M > *smartresult = result ? new ext::shared_ptr<  EURLibor7M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor7M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor7M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor7M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor7M *)new EURLibor7M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor7M > *smartresult = result ? new ext::shared_ptr<  EURLibor7M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor7M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor7M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor7M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor7M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor7M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor7M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor7M::EURLibor7M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor7M::EURLibor7M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor7M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor7M *arg1 = (EURLibor7M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor7M > tempshared1 ;
  ext::shared_ptr< EURLibor7M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor7M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor7M" "', argument " "1"" of type '" "EURLibor7M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor7M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor7M > * >(argp1);
      arg1 = const_cast< EURLibor7M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor7M > * >(argp1);
      arg1 = const_cast< EURLibor7M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor7M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor7M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor7M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor8M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor8M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor8M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor8M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor8M *)new EURLibor8M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor8M > *smartresult = result ? new ext::shared_ptr<  EURLibor8M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor8M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor8M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor8M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor8M *)new EURLibor8M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor8M > *smartresult = result ? new ext::shared_ptr<  EURLibor8M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor8M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor8M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor8M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor8M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor8M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor8M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor8M::EURLibor8M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor8M::EURLibor8M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor8M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor8M *arg1 = (EURLibor8M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor8M > tempshared1 ;
  ext::shared_ptr< EURLibor8M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor8M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor8M" "', argument " "1"" of type '" "EURLibor8M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor8M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor8M > * >(argp1);
      arg1 = const_cast< EURLibor8M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor8M > * >(argp1);
      arg1 = const_cast< EURLibor8M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor8M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor8M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor8M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor9M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor9M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor9M *)new EURLibor9M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor9M > *smartresult = result ? new ext::shared_ptr<  EURLibor9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor9M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor9M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor9M *)new EURLibor9M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor9M > *smartresult = result ? new ext::shared_ptr<  EURLibor9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor9M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor9M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor9M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor9M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor9M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor9M::EURLibor9M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor9M::EURLibor9M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor9M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor9M *arg1 = (EURLibor9M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor9M > tempshared1 ;
  ext::shared_ptr< EURLibor9M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor9M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor9M" "', argument " "1"" of type '" "EURLibor9M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor9M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor9M > * >(argp1);
      arg1 = const_cast< EURLibor9M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor9M > * >(argp1);
      arg1 = const_cast< EURLibor9M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor9M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor9M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor9M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor10M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor10M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor10M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor10M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor10M *)new EURLibor10M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor10M > *smartresult = result ? new ext::shared_ptr<  EURLibor10M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor10M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor10M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor10M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor10M *)new EURLibor10M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor10M > *smartresult = result ? new ext::shared_ptr<  EURLibor10M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor10M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor10M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor10M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor10M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor10M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor10M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor10M::EURLibor10M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor10M::EURLibor10M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor10M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor10M *arg1 = (EURLibor10M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor10M > tempshared1 ;
  ext::shared_ptr< EURLibor10M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor10M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor10M" "', argument " "1"" of type '" "EURLibor10M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor10M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor10M > * >(argp1);
      arg1 = const_cast< EURLibor10M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor10M > * >(argp1);
      arg1 = const_cast< EURLibor10M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor10M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor10M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor10M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor11M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor11M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor11M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor11M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor11M *)new EURLibor11M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor11M > *smartresult = result ? new ext::shared_ptr<  EURLibor11M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor11M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor11M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor11M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor11M *)new EURLibor11M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor11M > *smartresult = result ? new ext::shared_ptr<  EURLibor11M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor11M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor11M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor11M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor11M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor11M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor11M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor11M::EURLibor11M(Handle< YieldTermStructure > const &)\n"
    "    EURLibor11M::EURLibor11M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor11M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor11M *arg1 = (EURLibor11M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor11M > tempshared1 ;
  ext::shared_ptr< EURLibor11M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor11M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor11M" "', argument " "1"" of type '" "EURLibor11M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor11M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor11M > * >(argp1);
      arg1 = const_cast< EURLibor11M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor11M > * >(argp1);
      arg1 = const_cast< EURLibor11M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor11M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor11M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor11M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EURLibor1Y__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EURLibor1Y *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EURLibor1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EURLibor1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (EURLibor1Y *)new EURLibor1Y((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor1Y > *smartresult = result ? new ext::shared_ptr<  EURLibor1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor1Y__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EURLibor1Y *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EURLibor1Y *)new EURLibor1Y();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EURLibor1Y > *smartresult = result ? new ext::shared_ptr<  EURLibor1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EURLibor1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EURLibor1Y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EURLibor1Y", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EURLibor1Y__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EURLibor1Y__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EURLibor1Y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EURLibor1Y::EURLibor1Y(Handle< YieldTermStructure > const &)\n"
    "    EURLibor1Y::EURLibor1Y()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EURLibor1Y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EURLibor1Y *arg1 = (EURLibor1Y *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EURLibor1Y > tempshared1 ;
  ext::shared_ptr< EURLibor1Y > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EURLibor1Y_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EURLibor1Y" "', argument " "1"" of type '" "EURLibor1Y *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EURLibor1Y > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EURLibor1Y > * >(argp1);
      arg1 = const_cast< EURLibor1Y * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EURLibor1Y > * >(argp1);
      arg1 = const_cast< EURLibor1Y * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EURLibor1Y_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EURLibor1Y_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EURLibor1Y_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GBPLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  GBPLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBPLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GBPLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GBPLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GBPLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (GBPLibor *)new GBPLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GBPLibor > *smartresult = result ? new ext::shared_ptr<  GBPLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GBPLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GBPLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GBPLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBPLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GBPLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (GBPLibor *)new GBPLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GBPLibor > *smartresult = result ? new ext::shared_ptr<  GBPLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GBPLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GBPLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GBPLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GBPLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GBPLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GBPLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GBPLibor::GBPLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    GBPLibor::GBPLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GBPLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GBPLibor *arg1 = (GBPLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GBPLibor > tempshared1 ;
  ext::shared_ptr< GBPLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GBPLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPLibor" "', argument " "1"" of type '" "GBPLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GBPLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GBPLibor > * >(argp1);
      arg1 = const_cast< GBPLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GBPLibor > * >(argp1);
      arg1 = const_cast< GBPLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GBPLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GBPLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GBPLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GBPLiborON__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GBPLiborON *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBPLiborON" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GBPLiborON" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (GBPLiborON *)new GBPLiborON((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GBPLiborON > *smartresult = result ? new ext::shared_ptr<  GBPLiborON >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GBPLiborON_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GBPLiborON__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  GBPLiborON *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (GBPLiborON *)new GBPLiborON();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GBPLiborON > *smartresult = result ? new ext::shared_ptr<  GBPLiborON >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GBPLiborON_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GBPLiborON(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GBPLiborON", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GBPLiborON__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GBPLiborON__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GBPLiborON'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GBPLiborON::GBPLiborON(Handle< YieldTermStructure > const &)\n"
    "    GBPLiborON::GBPLiborON()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GBPLiborON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GBPLiborON *arg1 = (GBPLiborON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GBPLiborON > tempshared1 ;
  ext::shared_ptr< GBPLiborON > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GBPLiborON_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPLiborON" "', argument " "1"" of type '" "GBPLiborON *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GBPLiborON > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GBPLiborON > * >(argp1);
      arg1 = const_cast< GBPLiborON * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GBPLiborON > * >(argp1);
      arg1 = const_cast< GBPLiborON * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GBPLiborON_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GBPLiborON_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GBPLiborON_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Jibar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Jibar *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Jibar" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Jibar" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Jibar" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Jibar" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Jibar *)new Jibar((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Jibar > *smartresult = result ? new ext::shared_ptr<  Jibar >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Jibar_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Jibar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Jibar *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Jibar" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Jibar" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Jibar *)new Jibar((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Jibar > *smartresult = result ? new ext::shared_ptr<  Jibar >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Jibar_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Jibar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Jibar", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Jibar__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Jibar__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Jibar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Jibar::Jibar(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Jibar::Jibar(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Jibar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Jibar *arg1 = (Jibar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Jibar > tempshared1 ;
  ext::shared_ptr< Jibar > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Jibar_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Jibar" "', argument " "1"" of type '" "Jibar *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Jibar > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Jibar > * >(argp1);
      arg1 = const_cast< Jibar * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Jibar > * >(argp1);
      arg1 = const_cast< Jibar * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Jibar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Jibar_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Jibar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_JPYLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  JPYLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JPYLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JPYLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JPYLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JPYLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (JPYLibor *)new JPYLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JPYLibor > *smartresult = result ? new ext::shared_ptr<  JPYLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JPYLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JPYLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  JPYLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JPYLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JPYLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (JPYLibor *)new JPYLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JPYLibor > *smartresult = result ? new ext::shared_ptr<  JPYLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JPYLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JPYLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_JPYLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JPYLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_JPYLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JPYLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JPYLibor::JPYLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    JPYLibor::JPYLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_JPYLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  JPYLibor *arg1 = (JPYLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< JPYLibor > tempshared1 ;
  ext::shared_ptr< JPYLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_JPYLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JPYLibor" "', argument " "1"" of type '" "JPYLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  JPYLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  JPYLibor > * >(argp1);
      arg1 = const_cast< JPYLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  JPYLibor > * >(argp1);
      arg1 = const_cast< JPYLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JPYLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_JPYLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *JPYLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Mosprime__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Mosprime *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mosprime" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mosprime" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Mosprime" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mosprime" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Mosprime *)new Mosprime((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Mosprime > *smartresult = result ? new ext::shared_ptr<  Mosprime >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Mosprime_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mosprime__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Mosprime *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mosprime" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mosprime" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Mosprime *)new Mosprime((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Mosprime > *smartresult = result ? new ext::shared_ptr<  Mosprime >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Mosprime_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mosprime(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mosprime", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Mosprime__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Mosprime__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Mosprime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Mosprime::Mosprime(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Mosprime::Mosprime(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Mosprime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Mosprime *arg1 = (Mosprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Mosprime > tempshared1 ;
  ext::shared_ptr< Mosprime > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Mosprime_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mosprime" "', argument " "1"" of type '" "Mosprime *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Mosprime > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Mosprime > * >(argp1);
      arg1 = const_cast< Mosprime * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Mosprime > * >(argp1);
      arg1 = const_cast< Mosprime * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Mosprime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Mosprime_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Mosprime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NZDLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  NZDLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NZDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NZDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NZDLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NZDLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (NZDLibor *)new NZDLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NZDLibor > *smartresult = result ? new ext::shared_ptr<  NZDLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NZDLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NZDLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  NZDLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NZDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NZDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (NZDLibor *)new NZDLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NZDLibor > *smartresult = result ? new ext::shared_ptr<  NZDLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NZDLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NZDLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NZDLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NZDLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NZDLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NZDLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NZDLibor::NZDLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    NZDLibor::NZDLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NZDLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NZDLibor *arg1 = (NZDLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NZDLibor > tempshared1 ;
  ext::shared_ptr< NZDLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NZDLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NZDLibor" "', argument " "1"" of type '" "NZDLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NZDLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NZDLibor > * >(argp1);
      arg1 = const_cast< NZDLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NZDLibor > * >(argp1);
      arg1 = const_cast< NZDLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NZDLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NZDLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NZDLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Pribor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Pribor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Pribor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pribor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Pribor *)new Pribor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Pribor > *smartresult = result ? new ext::shared_ptr<  Pribor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Pribor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pribor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Pribor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pribor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Pribor *)new Pribor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Pribor > *smartresult = result ? new ext::shared_ptr<  Pribor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Pribor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pribor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Pribor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Pribor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Pribor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Pribor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pribor::Pribor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Pribor::Pribor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Pribor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Pribor *arg1 = (Pribor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Pribor > tempshared1 ;
  ext::shared_ptr< Pribor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Pribor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pribor" "', argument " "1"" of type '" "Pribor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Pribor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Pribor > * >(argp1);
      arg1 = const_cast< Pribor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Pribor > * >(argp1);
      arg1 = const_cast< Pribor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Pribor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Pribor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Pribor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Robor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Robor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Robor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Robor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Robor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Robor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Robor *)new Robor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Robor > *smartresult = result ? new ext::shared_ptr<  Robor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Robor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Robor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Robor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Robor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Robor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Robor *)new Robor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Robor > *smartresult = result ? new ext::shared_ptr<  Robor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Robor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Robor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Robor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Robor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Robor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Robor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Robor::Robor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Robor::Robor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Robor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Robor *arg1 = (Robor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Robor > tempshared1 ;
  ext::shared_ptr< Robor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Robor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Robor" "', argument " "1"" of type '" "Robor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Robor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Robor > * >(argp1);
      arg1 = const_cast< Robor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Robor > * >(argp1);
      arg1 = const_cast< Robor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Robor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Robor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Robor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SEKLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SEKLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SEKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SEKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SEKLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SEKLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (SEKLibor *)new SEKLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SEKLibor > *smartresult = result ? new ext::shared_ptr<  SEKLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SEKLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SEKLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SEKLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SEKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SEKLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (SEKLibor *)new SEKLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SEKLibor > *smartresult = result ? new ext::shared_ptr<  SEKLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SEKLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SEKLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SEKLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SEKLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SEKLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SEKLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SEKLibor::SEKLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    SEKLibor::SEKLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SEKLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SEKLibor *arg1 = (SEKLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SEKLibor > tempshared1 ;
  ext::shared_ptr< SEKLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SEKLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SEKLibor" "', argument " "1"" of type '" "SEKLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SEKLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SEKLibor > * >(argp1);
      arg1 = const_cast< SEKLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SEKLibor > * >(argp1);
      arg1 = const_cast< SEKLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SEKLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SEKLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SEKLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Shibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Shibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Shibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Shibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Shibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Shibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Shibor *)new Shibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Shibor > *smartresult = result ? new ext::shared_ptr<  Shibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Shibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Shibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Shibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Shibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Shibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Shibor *)new Shibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Shibor > *smartresult = result ? new ext::shared_ptr<  Shibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Shibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Shibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Shibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Shibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Shibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Shibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Shibor::Shibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Shibor::Shibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Shibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Shibor *arg1 = (Shibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Shibor > tempshared1 ;
  ext::shared_ptr< Shibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Shibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Shibor" "', argument " "1"" of type '" "Shibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Shibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Shibor > * >(argp1);
      arg1 = const_cast< Shibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Shibor > * >(argp1);
      arg1 = const_cast< Shibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Shibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Shibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Shibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Tibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Tibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Tibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Tibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Tibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Tibor *)new Tibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Tibor > *smartresult = result ? new ext::shared_ptr<  Tibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Tibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Tibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Tibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Tibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Tibor *)new Tibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Tibor > *smartresult = result ? new ext::shared_ptr<  Tibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Tibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Tibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Tibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Tibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Tibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Tibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Tibor::Tibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Tibor::Tibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Tibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Tibor *arg1 = (Tibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Tibor > tempshared1 ;
  ext::shared_ptr< Tibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Tibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Tibor" "', argument " "1"" of type '" "Tibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Tibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Tibor > * >(argp1);
      arg1 = const_cast< Tibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Tibor > * >(argp1);
      arg1 = const_cast< Tibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Tibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Tibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Tibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_THBFIX__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  THBFIX *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_THBFIX" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_THBFIX" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_THBFIX" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_THBFIX" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (THBFIX *)new THBFIX((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  THBFIX > *smartresult = result ? new ext::shared_ptr<  THBFIX >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_THBFIX_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_THBFIX__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  THBFIX *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_THBFIX" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_THBFIX" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (THBFIX *)new THBFIX((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  THBFIX > *smartresult = result ? new ext::shared_ptr<  THBFIX >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_THBFIX_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_THBFIX(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_THBFIX", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_THBFIX__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_THBFIX__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_THBFIX'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    THBFIX::THBFIX(Period const &,Handle< YieldTermStructure > const &)\n"
    "    THBFIX::THBFIX(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_THBFIX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  THBFIX *arg1 = (THBFIX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< THBFIX > tempshared1 ;
  ext::shared_ptr< THBFIX > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_THBFIX_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_THBFIX" "', argument " "1"" of type '" "THBFIX *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  THBFIX > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  THBFIX > * >(argp1);
      arg1 = const_cast< THBFIX * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  THBFIX > * >(argp1);
      arg1 = const_cast< THBFIX * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *THBFIX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_THBFIX_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *THBFIX_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TRLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  TRLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TRLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TRLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TRLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (TRLibor *)new TRLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TRLibor > *smartresult = result ? new ext::shared_ptr<  TRLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TRLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TRLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  TRLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TRLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TRLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (TRLibor *)new TRLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TRLibor > *smartresult = result ? new ext::shared_ptr<  TRLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TRLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TRLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TRLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TRLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TRLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TRLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TRLibor::TRLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    TRLibor::TRLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TRLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TRLibor *arg1 = (TRLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TRLibor > tempshared1 ;
  ext::shared_ptr< TRLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TRLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TRLibor" "', argument " "1"" of type '" "TRLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TRLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TRLibor > * >(argp1);
      arg1 = const_cast< TRLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TRLibor > * >(argp1);
      arg1 = const_cast< TRLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TRLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TRLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TRLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_USDLibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  USDLibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_USDLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USDLibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (USDLibor *)new USDLibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USDLibor > *smartresult = result ? new ext::shared_ptr<  USDLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USDLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USDLibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  USDLibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USDLibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (USDLibor *)new USDLibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USDLibor > *smartresult = result ? new ext::shared_ptr<  USDLibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USDLibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USDLibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_USDLibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_USDLibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_USDLibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_USDLibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    USDLibor::USDLibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    USDLibor::USDLibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_USDLibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  USDLibor *arg1 = (USDLibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< USDLibor > tempshared1 ;
  ext::shared_ptr< USDLibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_USDLibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_USDLibor" "', argument " "1"" of type '" "USDLibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  USDLibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  USDLibor > * >(argp1);
      arg1 = const_cast< USDLibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  USDLibor > * >(argp1);
      arg1 = const_cast< USDLibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *USDLibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_USDLibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *USDLibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_USDLiborON__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  USDLiborON *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USDLiborON" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USDLiborON" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (USDLiborON *)new USDLiborON((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USDLiborON > *smartresult = result ? new ext::shared_ptr<  USDLiborON >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USDLiborON_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USDLiborON__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  USDLiborON *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (USDLiborON *)new USDLiborON();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USDLiborON > *smartresult = result ? new ext::shared_ptr<  USDLiborON >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USDLiborON_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USDLiborON(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_USDLiborON", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_USDLiborON__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_USDLiborON__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_USDLiborON'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    USDLiborON::USDLiborON(Handle< YieldTermStructure > const &)\n"
    "    USDLiborON::USDLiborON()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_USDLiborON(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  USDLiborON *arg1 = (USDLiborON *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< USDLiborON > tempshared1 ;
  ext::shared_ptr< USDLiborON > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_USDLiborON_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_USDLiborON" "', argument " "1"" of type '" "USDLiborON *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  USDLiborON > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  USDLiborON > * >(argp1);
      arg1 = const_cast< USDLiborON * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  USDLiborON > * >(argp1);
      arg1 = const_cast< USDLiborON * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *USDLiborON_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_USDLiborON_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *USDLiborON_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Wibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Wibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Wibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Wibor *)new Wibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Wibor > *smartresult = result ? new ext::shared_ptr<  Wibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Wibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Wibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Wibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Wibor *)new Wibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Wibor > *smartresult = result ? new ext::shared_ptr<  Wibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Wibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Wibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Wibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Wibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Wibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Wibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Wibor::Wibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Wibor::Wibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Wibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Wibor *arg1 = (Wibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Wibor > tempshared1 ;
  ext::shared_ptr< Wibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Wibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wibor" "', argument " "1"" of type '" "Wibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Wibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Wibor > * >(argp1);
      arg1 = const_cast< Wibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Wibor > * >(argp1);
      arg1 = const_cast< Wibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Wibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Wibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Wibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Zibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Zibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Zibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Zibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Zibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Zibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Zibor *)new Zibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Zibor > *smartresult = result ? new ext::shared_ptr<  Zibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Zibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Zibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Zibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Zibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Zibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Zibor *)new Zibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Zibor > *smartresult = result ? new ext::shared_ptr<  Zibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Zibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Zibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Zibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Zibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Zibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Zibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Zibor::Zibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Zibor::Zibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Zibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Zibor *arg1 = (Zibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Zibor > tempshared1 ;
  ext::shared_ptr< Zibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Zibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Zibor" "', argument " "1"" of type '" "Zibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Zibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Zibor > * >(argp1);
      arg1 = const_cast< Zibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Zibor > * >(argp1);
      arg1 = const_cast< Zibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Zibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Zibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Zibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Aonia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Aonia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Aonia" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Aonia" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Aonia *)new Aonia((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Aonia > *smartresult = result ? new ext::shared_ptr<  Aonia >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Aonia_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Aonia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Aonia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Aonia *)new Aonia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Aonia > *smartresult = result ? new ext::shared_ptr<  Aonia >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Aonia_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Aonia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Aonia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Aonia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Aonia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Aonia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Aonia::Aonia(Handle< YieldTermStructure > const &)\n"
    "    Aonia::Aonia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Aonia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Aonia *arg1 = (Aonia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Aonia > tempshared1 ;
  ext::shared_ptr< Aonia > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Aonia_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Aonia" "', argument " "1"" of type '" "Aonia *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Aonia > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Aonia > * >(argp1);
      arg1 = const_cast< Aonia * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Aonia > * >(argp1);
      arg1 = const_cast< Aonia * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Aonia_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Aonia_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Aonia_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Corra__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Corra *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Corra" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Corra" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Corra *)new Corra((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Corra > *smartresult = result ? new ext::shared_ptr<  Corra >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Corra_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Corra__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Corra *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Corra *)new Corra();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Corra > *smartresult = result ? new ext::shared_ptr<  Corra >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Corra_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Corra(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Corra", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Corra__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Corra__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Corra'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Corra::Corra(Handle< YieldTermStructure > const &)\n"
    "    Corra::Corra()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Corra(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Corra *arg1 = (Corra *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Corra > tempshared1 ;
  ext::shared_ptr< Corra > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Corra_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Corra" "', argument " "1"" of type '" "Corra *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Corra > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Corra > * >(argp1);
      arg1 = const_cast< Corra * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Corra > * >(argp1);
      arg1 = const_cast< Corra * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Corra_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Corra_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Corra_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Destr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Destr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Destr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Destr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Destr *)new Destr((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Destr > *smartresult = result ? new ext::shared_ptr<  Destr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Destr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Destr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Destr *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Destr *)new Destr();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Destr > *smartresult = result ? new ext::shared_ptr<  Destr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Destr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Destr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Destr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Destr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Destr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Destr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Destr::Destr(Handle< YieldTermStructure > const &)\n"
    "    Destr::Destr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Destr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Destr *arg1 = (Destr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Destr > tempshared1 ;
  ext::shared_ptr< Destr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Destr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Destr" "', argument " "1"" of type '" "Destr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Destr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Destr > * >(argp1);
      arg1 = const_cast< Destr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Destr > * >(argp1);
      arg1 = const_cast< Destr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Destr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Destr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Destr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Eonia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Eonia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Eonia" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Eonia" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Eonia *)new Eonia((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Eonia > *smartresult = result ? new ext::shared_ptr<  Eonia >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Eonia_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Eonia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Eonia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Eonia *)new Eonia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Eonia > *smartresult = result ? new ext::shared_ptr<  Eonia >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Eonia_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Eonia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Eonia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Eonia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Eonia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Eonia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Eonia::Eonia(Handle< YieldTermStructure > const &)\n"
    "    Eonia::Eonia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Eonia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Eonia *arg1 = (Eonia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Eonia > tempshared1 ;
  ext::shared_ptr< Eonia > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Eonia_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Eonia" "', argument " "1"" of type '" "Eonia *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Eonia > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Eonia > * >(argp1);
      arg1 = const_cast< Eonia * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Eonia > * >(argp1);
      arg1 = const_cast< Eonia * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Eonia_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Eonia_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Eonia_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Estr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Estr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Estr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Estr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Estr *)new Estr((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Estr > *smartresult = result ? new ext::shared_ptr<  Estr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Estr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Estr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Estr *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Estr *)new Estr();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Estr > *smartresult = result ? new ext::shared_ptr<  Estr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Estr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Estr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Estr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Estr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Estr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Estr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Estr::Estr(Handle< YieldTermStructure > const &)\n"
    "    Estr::Estr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Estr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Estr *arg1 = (Estr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Estr > tempshared1 ;
  ext::shared_ptr< Estr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Estr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Estr" "', argument " "1"" of type '" "Estr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Estr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Estr > * >(argp1);
      arg1 = const_cast< Estr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Estr > * >(argp1);
      arg1 = const_cast< Estr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Estr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Estr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Estr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FedFunds__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FedFunds *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FedFunds" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FedFunds" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (FedFunds *)new FedFunds((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FedFunds > *smartresult = result ? new ext::shared_ptr<  FedFunds >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FedFunds_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FedFunds__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FedFunds *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (FedFunds *)new FedFunds();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FedFunds > *smartresult = result ? new ext::shared_ptr<  FedFunds >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FedFunds_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FedFunds(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FedFunds", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FedFunds__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FedFunds__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FedFunds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FedFunds::FedFunds(Handle< YieldTermStructure > const &)\n"
    "    FedFunds::FedFunds()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FedFunds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FedFunds *arg1 = (FedFunds *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FedFunds > tempshared1 ;
  ext::shared_ptr< FedFunds > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FedFunds_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FedFunds" "', argument " "1"" of type '" "FedFunds *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FedFunds > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FedFunds > * >(argp1);
      arg1 = const_cast< FedFunds * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FedFunds > * >(argp1);
      arg1 = const_cast< FedFunds * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FedFunds_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FedFunds_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FedFunds_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Nzocr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Nzocr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nzocr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nzocr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Nzocr *)new Nzocr((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Nzocr > *smartresult = result ? new ext::shared_ptr<  Nzocr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Nzocr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nzocr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Nzocr *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Nzocr *)new Nzocr();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Nzocr > *smartresult = result ? new ext::shared_ptr<  Nzocr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Nzocr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nzocr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Nzocr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Nzocr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nzocr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Nzocr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Nzocr::Nzocr(Handle< YieldTermStructure > const &)\n"
    "    Nzocr::Nzocr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nzocr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Nzocr *arg1 = (Nzocr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Nzocr > tempshared1 ;
  ext::shared_ptr< Nzocr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Nzocr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nzocr" "', argument " "1"" of type '" "Nzocr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Nzocr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Nzocr > * >(argp1);
      arg1 = const_cast< Nzocr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Nzocr > * >(argp1);
      arg1 = const_cast< Nzocr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nzocr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Nzocr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Nzocr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Sofr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Sofr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Sofr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Sofr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Sofr *)new Sofr((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Sofr > *smartresult = result ? new ext::shared_ptr<  Sofr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Sofr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sofr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Sofr *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Sofr *)new Sofr();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Sofr > *smartresult = result ? new ext::shared_ptr<  Sofr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Sofr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sofr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Sofr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Sofr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Sofr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Sofr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Sofr::Sofr(Handle< YieldTermStructure > const &)\n"
    "    Sofr::Sofr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Sofr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sofr *arg1 = (Sofr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Sofr > tempshared1 ;
  ext::shared_ptr< Sofr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Sofr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sofr" "', argument " "1"" of type '" "Sofr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Sofr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Sofr > * >(argp1);
      arg1 = const_cast< Sofr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Sofr > * >(argp1);
      arg1 = const_cast< Sofr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sofr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Sofr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Sofr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Sonia__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Sonia *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Sonia" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Sonia" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Sonia *)new Sonia((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Sonia > *smartresult = result ? new ext::shared_ptr<  Sonia >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Sonia_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sonia__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Sonia *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Sonia *)new Sonia();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Sonia > *smartresult = result ? new ext::shared_ptr<  Sonia >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Sonia_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sonia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Sonia", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Sonia__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Sonia__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Sonia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Sonia::Sonia(Handle< YieldTermStructure > const &)\n"
    "    Sonia::Sonia()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Sonia(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sonia *arg1 = (Sonia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Sonia > tempshared1 ;
  ext::shared_ptr< Sonia > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Sonia_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sonia" "', argument " "1"" of type '" "Sonia *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Sonia > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Sonia > * >(argp1);
      arg1 = const_cast< Sonia * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Sonia > * >(argp1);
      arg1 = const_cast< Sonia * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sonia_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Sonia_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Sonia_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Swestr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swestr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Swestr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Swestr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Swestr *)new Swestr((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swestr > *smartresult = result ? new ext::shared_ptr<  Swestr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swestr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swestr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Swestr *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Swestr *)new Swestr();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swestr > *smartresult = result ? new ext::shared_ptr<  Swestr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swestr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swestr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Swestr", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Swestr__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Swestr__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Swestr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Swestr::Swestr(Handle< YieldTermStructure > const &)\n"
    "    Swestr::Swestr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Swestr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swestr *arg1 = (Swestr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swestr > tempshared1 ;
  ext::shared_ptr< Swestr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swestr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Swestr" "', argument " "1"" of type '" "Swestr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swestr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swestr > * >(argp1);
      arg1 = const_cast< Swestr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swestr > * >(argp1);
      arg1 = const_cast< Swestr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Swestr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Swestr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Swestr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixA__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EuriborSwapIsdaFixA *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuriborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EuriborSwapIsdaFixA *)new EuriborSwapIsdaFixA((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIsdaFixA > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixA__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EuriborSwapIsdaFixA *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EuriborSwapIsdaFixA *)new EuriborSwapIsdaFixA((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIsdaFixA > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixA__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  EuriborSwapIsdaFixA *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuriborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EuriborSwapIsdaFixA" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixA" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (EuriborSwapIsdaFixA *)new EuriborSwapIsdaFixA((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIsdaFixA > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixA(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EuriborSwapIsdaFixA", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EuriborSwapIsdaFixA__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EuriborSwapIsdaFixA__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EuriborSwapIsdaFixA__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EuriborSwapIsdaFixA'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EuriborSwapIsdaFixA::EuriborSwapIsdaFixA(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EuriborSwapIsdaFixA::EuriborSwapIsdaFixA(Period const &)\n"
    "    EuriborSwapIsdaFixA::EuriborSwapIsdaFixA(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EuriborSwapIsdaFixA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EuriborSwapIsdaFixA *arg1 = (EuriborSwapIsdaFixA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EuriborSwapIsdaFixA > tempshared1 ;
  ext::shared_ptr< EuriborSwapIsdaFixA > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EuriborSwapIsdaFixA" "', argument " "1"" of type '" "EuriborSwapIsdaFixA *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EuriborSwapIsdaFixA > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EuriborSwapIsdaFixA > * >(argp1);
      arg1 = const_cast< EuriborSwapIsdaFixA * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EuriborSwapIsdaFixA > * >(argp1);
      arg1 = const_cast< EuriborSwapIsdaFixA * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EuriborSwapIsdaFixA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixA_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EuriborSwapIsdaFixA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixB__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EuriborSwapIsdaFixB *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuriborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EuriborSwapIsdaFixB *)new EuriborSwapIsdaFixB((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIsdaFixB > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixB__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EuriborSwapIsdaFixB *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EuriborSwapIsdaFixB *)new EuriborSwapIsdaFixB((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIsdaFixB > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixB__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  EuriborSwapIsdaFixB *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuriborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EuriborSwapIsdaFixB" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIsdaFixB" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (EuriborSwapIsdaFixB *)new EuriborSwapIsdaFixB((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIsdaFixB > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIsdaFixB(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EuriborSwapIsdaFixB", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EuriborSwapIsdaFixB__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EuriborSwapIsdaFixB__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EuriborSwapIsdaFixB__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EuriborSwapIsdaFixB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EuriborSwapIsdaFixB::EuriborSwapIsdaFixB(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EuriborSwapIsdaFixB::EuriborSwapIsdaFixB(Period const &)\n"
    "    EuriborSwapIsdaFixB::EuriborSwapIsdaFixB(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EuriborSwapIsdaFixB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EuriborSwapIsdaFixB *arg1 = (EuriborSwapIsdaFixB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EuriborSwapIsdaFixB > tempshared1 ;
  ext::shared_ptr< EuriborSwapIsdaFixB > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EuriborSwapIsdaFixB" "', argument " "1"" of type '" "EuriborSwapIsdaFixB *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EuriborSwapIsdaFixB > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EuriborSwapIsdaFixB > * >(argp1);
      arg1 = const_cast< EuriborSwapIsdaFixB * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EuriborSwapIsdaFixB > * >(argp1);
      arg1 = const_cast< EuriborSwapIsdaFixB * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EuriborSwapIsdaFixB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIsdaFixB_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EuriborSwapIsdaFixB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EuriborSwapIfrFix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EuriborSwapIfrFix *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuriborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EuriborSwapIfrFix *)new EuriborSwapIfrFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIfrFix > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIfrFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIfrFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIfrFix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EuriborSwapIfrFix *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EuriborSwapIfrFix *)new EuriborSwapIfrFix((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIfrFix > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIfrFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIfrFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIfrFix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  EuriborSwapIfrFix *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuriborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuriborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EuriborSwapIfrFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuriborSwapIfrFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (EuriborSwapIfrFix *)new EuriborSwapIfrFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuriborSwapIfrFix > *smartresult = result ? new ext::shared_ptr<  EuriborSwapIfrFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIfrFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EuriborSwapIfrFix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EuriborSwapIfrFix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EuriborSwapIfrFix__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EuriborSwapIfrFix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EuriborSwapIfrFix__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EuriborSwapIfrFix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EuriborSwapIfrFix::EuriborSwapIfrFix(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EuriborSwapIfrFix::EuriborSwapIfrFix(Period const &)\n"
    "    EuriborSwapIfrFix::EuriborSwapIfrFix(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EuriborSwapIfrFix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EuriborSwapIfrFix *arg1 = (EuriborSwapIfrFix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EuriborSwapIfrFix > tempshared1 ;
  ext::shared_ptr< EuriborSwapIfrFix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIfrFix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EuriborSwapIfrFix" "', argument " "1"" of type '" "EuriborSwapIfrFix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EuriborSwapIfrFix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EuriborSwapIfrFix > * >(argp1);
      arg1 = const_cast< EuriborSwapIfrFix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EuriborSwapIfrFix > * >(argp1);
      arg1 = const_cast< EuriborSwapIfrFix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EuriborSwapIfrFix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EuriborSwapIfrFix_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EuriborSwapIfrFix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixA__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EurLiborSwapIsdaFixA *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EurLiborSwapIsdaFixA *)new EurLiborSwapIsdaFixA((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIsdaFixA > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixA__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EurLiborSwapIsdaFixA *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EurLiborSwapIsdaFixA *)new EurLiborSwapIsdaFixA((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIsdaFixA > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixA__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  EurLiborSwapIsdaFixA *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixA" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (EurLiborSwapIsdaFixA *)new EurLiborSwapIsdaFixA((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIsdaFixA > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixA >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixA(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EurLiborSwapIsdaFixA", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EurLiborSwapIsdaFixA__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EurLiborSwapIsdaFixA__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EurLiborSwapIsdaFixA__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EurLiborSwapIsdaFixA'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EurLiborSwapIsdaFixA::EurLiborSwapIsdaFixA(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EurLiborSwapIsdaFixA::EurLiborSwapIsdaFixA(Period const &)\n"
    "    EurLiborSwapIsdaFixA::EurLiborSwapIsdaFixA(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EurLiborSwapIsdaFixA(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EurLiborSwapIsdaFixA *arg1 = (EurLiborSwapIsdaFixA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EurLiborSwapIsdaFixA > tempshared1 ;
  ext::shared_ptr< EurLiborSwapIsdaFixA > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EurLiborSwapIsdaFixA" "', argument " "1"" of type '" "EurLiborSwapIsdaFixA *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EurLiborSwapIsdaFixA > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EurLiborSwapIsdaFixA > * >(argp1);
      arg1 = const_cast< EurLiborSwapIsdaFixA * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EurLiborSwapIsdaFixA > * >(argp1);
      arg1 = const_cast< EurLiborSwapIsdaFixA * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EurLiborSwapIsdaFixA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EurLiborSwapIsdaFixA_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixB__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EurLiborSwapIsdaFixB *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EurLiborSwapIsdaFixB *)new EurLiborSwapIsdaFixB((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIsdaFixB > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixB__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EurLiborSwapIsdaFixB *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EurLiborSwapIsdaFixB *)new EurLiborSwapIsdaFixB((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIsdaFixB > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixB__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  EurLiborSwapIsdaFixB *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIsdaFixB" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (EurLiborSwapIsdaFixB *)new EurLiborSwapIsdaFixB((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIsdaFixB > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIsdaFixB >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIsdaFixB(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EurLiborSwapIsdaFixB", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EurLiborSwapIsdaFixB__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EurLiborSwapIsdaFixB__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EurLiborSwapIsdaFixB__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EurLiborSwapIsdaFixB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EurLiborSwapIsdaFixB::EurLiborSwapIsdaFixB(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EurLiborSwapIsdaFixB::EurLiborSwapIsdaFixB(Period const &)\n"
    "    EurLiborSwapIsdaFixB::EurLiborSwapIsdaFixB(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EurLiborSwapIsdaFixB(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EurLiborSwapIsdaFixB *arg1 = (EurLiborSwapIsdaFixB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EurLiborSwapIsdaFixB > tempshared1 ;
  ext::shared_ptr< EurLiborSwapIsdaFixB > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EurLiborSwapIsdaFixB" "', argument " "1"" of type '" "EurLiborSwapIsdaFixB *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EurLiborSwapIsdaFixB > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EurLiborSwapIsdaFixB > * >(argp1);
      arg1 = const_cast< EurLiborSwapIsdaFixB * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EurLiborSwapIsdaFixB > * >(argp1);
      arg1 = const_cast< EurLiborSwapIsdaFixB * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EurLiborSwapIsdaFixB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EurLiborSwapIsdaFixB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EurLiborSwapIfrFix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EurLiborSwapIfrFix *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EurLiborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (EurLiborSwapIfrFix *)new EurLiborSwapIfrFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIfrFix > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIfrFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIfrFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIfrFix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EurLiborSwapIfrFix *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (EurLiborSwapIfrFix *)new EurLiborSwapIfrFix((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIfrFix > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIfrFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIfrFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIfrFix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  EurLiborSwapIfrFix *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EurLiborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIfrFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EurLiborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIfrFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EurLiborSwapIfrFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EurLiborSwapIfrFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (EurLiborSwapIfrFix *)new EurLiborSwapIfrFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EurLiborSwapIfrFix > *smartresult = result ? new ext::shared_ptr<  EurLiborSwapIfrFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIfrFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EurLiborSwapIfrFix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EurLiborSwapIfrFix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EurLiborSwapIfrFix__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EurLiborSwapIfrFix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EurLiborSwapIfrFix__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EurLiborSwapIfrFix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EurLiborSwapIfrFix::EurLiborSwapIfrFix(Period const &,Handle< YieldTermStructure > const &)\n"
    "    EurLiborSwapIfrFix::EurLiborSwapIfrFix(Period const &)\n"
    "    EurLiborSwapIfrFix::EurLiborSwapIfrFix(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EurLiborSwapIfrFix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EurLiborSwapIfrFix *arg1 = (EurLiborSwapIfrFix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EurLiborSwapIfrFix > tempshared1 ;
  ext::shared_ptr< EurLiborSwapIfrFix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIfrFix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EurLiborSwapIfrFix" "', argument " "1"" of type '" "EurLiborSwapIfrFix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EurLiborSwapIfrFix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EurLiborSwapIfrFix > * >(argp1);
      arg1 = const_cast< EurLiborSwapIfrFix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EurLiborSwapIfrFix > * >(argp1);
      arg1 = const_cast< EurLiborSwapIfrFix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EurLiborSwapIfrFix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EurLiborSwapIfrFix_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EurLiborSwapIfrFix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ChfLiborSwapIsdaFix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ChfLiborSwapIsdaFix *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (ChfLiborSwapIsdaFix *)new ChfLiborSwapIsdaFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ChfLiborSwapIsdaFix > *smartresult = result ? new ext::shared_ptr<  ChfLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChfLiborSwapIsdaFix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ChfLiborSwapIsdaFix *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (ChfLiborSwapIsdaFix *)new ChfLiborSwapIsdaFix((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ChfLiborSwapIsdaFix > *smartresult = result ? new ext::shared_ptr<  ChfLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChfLiborSwapIsdaFix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ChfLiborSwapIsdaFix *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChfLiborSwapIsdaFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (ChfLiborSwapIsdaFix *)new ChfLiborSwapIsdaFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ChfLiborSwapIsdaFix > *smartresult = result ? new ext::shared_ptr<  ChfLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ChfLiborSwapIsdaFix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ChfLiborSwapIsdaFix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ChfLiborSwapIsdaFix__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ChfLiborSwapIsdaFix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ChfLiborSwapIsdaFix__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ChfLiborSwapIsdaFix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ChfLiborSwapIsdaFix::ChfLiborSwapIsdaFix(Period const &,Handle< YieldTermStructure > const &)\n"
    "    ChfLiborSwapIsdaFix::ChfLiborSwapIsdaFix(Period const &)\n"
    "    ChfLiborSwapIsdaFix::ChfLiborSwapIsdaFix(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ChfLiborSwapIsdaFix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ChfLiborSwapIsdaFix *arg1 = (ChfLiborSwapIsdaFix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ChfLiborSwapIsdaFix > tempshared1 ;
  ext::shared_ptr< ChfLiborSwapIsdaFix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChfLiborSwapIsdaFix" "', argument " "1"" of type '" "ChfLiborSwapIsdaFix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ChfLiborSwapIsdaFix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ChfLiborSwapIsdaFix > * >(argp1);
      arg1 = const_cast< ChfLiborSwapIsdaFix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ChfLiborSwapIsdaFix > * >(argp1);
      arg1 = const_cast< ChfLiborSwapIsdaFix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ChfLiborSwapIsdaFix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ChfLiborSwapIsdaFix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GbpLiborSwapIsdaFix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  GbpLiborSwapIsdaFix *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (GbpLiborSwapIsdaFix *)new GbpLiborSwapIsdaFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GbpLiborSwapIsdaFix > *smartresult = result ? new ext::shared_ptr<  GbpLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GbpLiborSwapIsdaFix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  GbpLiborSwapIsdaFix *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (GbpLiborSwapIsdaFix *)new GbpLiborSwapIsdaFix((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GbpLiborSwapIsdaFix > *smartresult = result ? new ext::shared_ptr<  GbpLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GbpLiborSwapIsdaFix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  GbpLiborSwapIsdaFix *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GbpLiborSwapIsdaFix" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (GbpLiborSwapIsdaFix *)new GbpLiborSwapIsdaFix((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GbpLiborSwapIsdaFix > *smartresult = result ? new ext::shared_ptr<  GbpLiborSwapIsdaFix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GbpLiborSwapIsdaFix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GbpLiborSwapIsdaFix", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GbpLiborSwapIsdaFix__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GbpLiborSwapIsdaFix__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_GbpLiborSwapIsdaFix__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GbpLiborSwapIsdaFix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GbpLiborSwapIsdaFix::GbpLiborSwapIsdaFix(Period const &,Handle< YieldTermStructure > const &)\n"
    "    GbpLiborSwapIsdaFix::GbpLiborSwapIsdaFix(Period const &)\n"
    "    GbpLiborSwapIsdaFix::GbpLiborSwapIsdaFix(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GbpLiborSwapIsdaFix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GbpLiborSwapIsdaFix *arg1 = (GbpLiborSwapIsdaFix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GbpLiborSwapIsdaFix > tempshared1 ;
  ext::shared_ptr< GbpLiborSwapIsdaFix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GbpLiborSwapIsdaFix" "', argument " "1"" of type '" "GbpLiborSwapIsdaFix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GbpLiborSwapIsdaFix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GbpLiborSwapIsdaFix > * >(argp1);
      arg1 = const_cast< GbpLiborSwapIsdaFix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GbpLiborSwapIsdaFix > * >(argp1);
      arg1 = const_cast< GbpLiborSwapIsdaFix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GbpLiborSwapIsdaFix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GbpLiborSwapIsdaFix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixAm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  JpyLiborSwapIsdaFixAm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (JpyLiborSwapIsdaFixAm *)new JpyLiborSwapIsdaFixAm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JpyLiborSwapIsdaFixAm > *smartresult = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixAm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  JpyLiborSwapIsdaFixAm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (JpyLiborSwapIsdaFixAm *)new JpyLiborSwapIsdaFixAm((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JpyLiborSwapIsdaFixAm > *smartresult = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixAm__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  JpyLiborSwapIsdaFixAm *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixAm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (JpyLiborSwapIsdaFixAm *)new JpyLiborSwapIsdaFixAm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JpyLiborSwapIsdaFixAm > *smartresult = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixAm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_JpyLiborSwapIsdaFixAm", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JpyLiborSwapIsdaFixAm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_JpyLiborSwapIsdaFixAm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_JpyLiborSwapIsdaFixAm__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JpyLiborSwapIsdaFixAm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JpyLiborSwapIsdaFixAm::JpyLiborSwapIsdaFixAm(Period const &,Handle< YieldTermStructure > const &)\n"
    "    JpyLiborSwapIsdaFixAm::JpyLiborSwapIsdaFixAm(Period const &)\n"
    "    JpyLiborSwapIsdaFixAm::JpyLiborSwapIsdaFixAm(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_JpyLiborSwapIsdaFixAm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  JpyLiborSwapIsdaFixAm *arg1 = (JpyLiborSwapIsdaFixAm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< JpyLiborSwapIsdaFixAm > tempshared1 ;
  ext::shared_ptr< JpyLiborSwapIsdaFixAm > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JpyLiborSwapIsdaFixAm" "', argument " "1"" of type '" "JpyLiborSwapIsdaFixAm *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  JpyLiborSwapIsdaFixAm > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  JpyLiborSwapIsdaFixAm > * >(argp1);
      arg1 = const_cast< JpyLiborSwapIsdaFixAm * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  JpyLiborSwapIsdaFixAm > * >(argp1);
      arg1 = const_cast< JpyLiborSwapIsdaFixAm * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JpyLiborSwapIsdaFixAm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *JpyLiborSwapIsdaFixAm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixPm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  JpyLiborSwapIsdaFixPm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (JpyLiborSwapIsdaFixPm *)new JpyLiborSwapIsdaFixPm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JpyLiborSwapIsdaFixPm > *smartresult = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixPm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  JpyLiborSwapIsdaFixPm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (JpyLiborSwapIsdaFixPm *)new JpyLiborSwapIsdaFixPm((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JpyLiborSwapIsdaFixPm > *smartresult = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixPm__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  JpyLiborSwapIsdaFixPm *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JpyLiborSwapIsdaFixPm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (JpyLiborSwapIsdaFixPm *)new JpyLiborSwapIsdaFixPm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JpyLiborSwapIsdaFixPm > *smartresult = result ? new ext::shared_ptr<  JpyLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JpyLiborSwapIsdaFixPm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_JpyLiborSwapIsdaFixPm", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JpyLiborSwapIsdaFixPm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_JpyLiborSwapIsdaFixPm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_JpyLiborSwapIsdaFixPm__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JpyLiborSwapIsdaFixPm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JpyLiborSwapIsdaFixPm::JpyLiborSwapIsdaFixPm(Period const &,Handle< YieldTermStructure > const &)\n"
    "    JpyLiborSwapIsdaFixPm::JpyLiborSwapIsdaFixPm(Period const &)\n"
    "    JpyLiborSwapIsdaFixPm::JpyLiborSwapIsdaFixPm(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_JpyLiborSwapIsdaFixPm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  JpyLiborSwapIsdaFixPm *arg1 = (JpyLiborSwapIsdaFixPm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< JpyLiborSwapIsdaFixPm > tempshared1 ;
  ext::shared_ptr< JpyLiborSwapIsdaFixPm > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JpyLiborSwapIsdaFixPm" "', argument " "1"" of type '" "JpyLiborSwapIsdaFixPm *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  JpyLiborSwapIsdaFixPm > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  JpyLiborSwapIsdaFixPm > * >(argp1);
      arg1 = const_cast< JpyLiborSwapIsdaFixPm * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  JpyLiborSwapIsdaFixPm > * >(argp1);
      arg1 = const_cast< JpyLiborSwapIsdaFixPm * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JpyLiborSwapIsdaFixPm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *JpyLiborSwapIsdaFixPm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixAm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  UsdLiborSwapIsdaFixAm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (UsdLiborSwapIsdaFixAm *)new UsdLiborSwapIsdaFixAm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UsdLiborSwapIsdaFixAm > *smartresult = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixAm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UsdLiborSwapIsdaFixAm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (UsdLiborSwapIsdaFixAm *)new UsdLiborSwapIsdaFixAm((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UsdLiborSwapIsdaFixAm > *smartresult = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixAm__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  UsdLiborSwapIsdaFixAm *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixAm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (UsdLiborSwapIsdaFixAm *)new UsdLiborSwapIsdaFixAm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UsdLiborSwapIsdaFixAm > *smartresult = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixAm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixAm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UsdLiborSwapIsdaFixAm", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UsdLiborSwapIsdaFixAm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UsdLiborSwapIsdaFixAm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_UsdLiborSwapIsdaFixAm__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UsdLiborSwapIsdaFixAm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UsdLiborSwapIsdaFixAm::UsdLiborSwapIsdaFixAm(Period const &,Handle< YieldTermStructure > const &)\n"
    "    UsdLiborSwapIsdaFixAm::UsdLiborSwapIsdaFixAm(Period const &)\n"
    "    UsdLiborSwapIsdaFixAm::UsdLiborSwapIsdaFixAm(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UsdLiborSwapIsdaFixAm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsdLiborSwapIsdaFixAm *arg1 = (UsdLiborSwapIsdaFixAm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UsdLiborSwapIsdaFixAm > tempshared1 ;
  ext::shared_ptr< UsdLiborSwapIsdaFixAm > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UsdLiborSwapIsdaFixAm" "', argument " "1"" of type '" "UsdLiborSwapIsdaFixAm *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UsdLiborSwapIsdaFixAm > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UsdLiborSwapIsdaFixAm > * >(argp1);
      arg1 = const_cast< UsdLiborSwapIsdaFixAm * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UsdLiborSwapIsdaFixAm > * >(argp1);
      arg1 = const_cast< UsdLiborSwapIsdaFixAm * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UsdLiborSwapIsdaFixAm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UsdLiborSwapIsdaFixAm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixPm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  UsdLiborSwapIsdaFixPm *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (UsdLiborSwapIsdaFixPm *)new UsdLiborSwapIsdaFixPm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UsdLiborSwapIsdaFixPm > *smartresult = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixPm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UsdLiborSwapIsdaFixPm *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (UsdLiborSwapIsdaFixPm *)new UsdLiborSwapIsdaFixPm((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UsdLiborSwapIsdaFixPm > *smartresult = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixPm__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  UsdLiborSwapIsdaFixPm *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UsdLiborSwapIsdaFixPm" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (UsdLiborSwapIsdaFixPm *)new UsdLiborSwapIsdaFixPm((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UsdLiborSwapIsdaFixPm > *smartresult = result ? new ext::shared_ptr<  UsdLiborSwapIsdaFixPm >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UsdLiborSwapIsdaFixPm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UsdLiborSwapIsdaFixPm", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UsdLiborSwapIsdaFixPm__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UsdLiborSwapIsdaFixPm__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_UsdLiborSwapIsdaFixPm__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UsdLiborSwapIsdaFixPm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UsdLiborSwapIsdaFixPm::UsdLiborSwapIsdaFixPm(Period const &,Handle< YieldTermStructure > const &)\n"
    "    UsdLiborSwapIsdaFixPm::UsdLiborSwapIsdaFixPm(Period const &)\n"
    "    UsdLiborSwapIsdaFixPm::UsdLiborSwapIsdaFixPm(Period const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UsdLiborSwapIsdaFixPm(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UsdLiborSwapIsdaFixPm *arg1 = (UsdLiborSwapIsdaFixPm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UsdLiborSwapIsdaFixPm > tempshared1 ;
  ext::shared_ptr< UsdLiborSwapIsdaFixPm > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UsdLiborSwapIsdaFixPm" "', argument " "1"" of type '" "UsdLiborSwapIsdaFixPm *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UsdLiborSwapIsdaFixPm > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UsdLiborSwapIsdaFixPm > * >(argp1);
      arg1 = const_cast< UsdLiborSwapIsdaFixPm * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UsdLiborSwapIsdaFixPm > * >(argp1);
      arg1 = const_cast< UsdLiborSwapIsdaFixPm * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UsdLiborSwapIsdaFixPm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UsdLiborSwapIsdaFixPm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Bibor *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Bibor *)new Bibor((Period const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor > *smartresult = result ? new ext::shared_ptr<  Bibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    try {
      result = (Bibor *)new Bibor((Period const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor > *smartresult = result ? new ext::shared_ptr<  Bibor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Bibor__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor::Bibor(Period const &,Handle< YieldTermStructure > const &)\n"
    "    Bibor::Bibor(Period const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor *arg1 = (Bibor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor > tempshared1 ;
  ext::shared_ptr< Bibor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor" "', argument " "1"" of type '" "Bibor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor > * >(argp1);
      arg1 = const_cast< Bibor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor > * >(argp1);
      arg1 = const_cast< Bibor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BiborSW__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BiborSW *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiborSW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BiborSW" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (BiborSW *)new BiborSW((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BiborSW > *smartresult = result ? new ext::shared_ptr<  BiborSW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BiborSW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BiborSW__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  BiborSW *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (BiborSW *)new BiborSW();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BiborSW > *smartresult = result ? new ext::shared_ptr<  BiborSW >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BiborSW_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BiborSW(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BiborSW", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BiborSW__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BiborSW__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BiborSW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BiborSW::BiborSW(Handle< YieldTermStructure > const &)\n"
    "    BiborSW::BiborSW()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BiborSW(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BiborSW *arg1 = (BiborSW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BiborSW > tempshared1 ;
  ext::shared_ptr< BiborSW > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BiborSW_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiborSW" "', argument " "1"" of type '" "BiborSW *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BiborSW > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BiborSW > * >(argp1);
      arg1 = const_cast< BiborSW * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BiborSW > * >(argp1);
      arg1 = const_cast< BiborSW * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BiborSW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BiborSW_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BiborSW_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor1M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor1M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor1M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bibor1M *)new Bibor1M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor1M > *smartresult = result ? new ext::shared_ptr<  Bibor1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor1M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bibor1M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bibor1M *)new Bibor1M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor1M > *smartresult = result ? new ext::shared_ptr<  Bibor1M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor1M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor1M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor1M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bibor1M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor1M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor1M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor1M::Bibor1M(Handle< YieldTermStructure > const &)\n"
    "    Bibor1M::Bibor1M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor1M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor1M *arg1 = (Bibor1M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor1M > tempshared1 ;
  ext::shared_ptr< Bibor1M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor1M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor1M" "', argument " "1"" of type '" "Bibor1M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor1M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor1M > * >(argp1);
      arg1 = const_cast< Bibor1M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor1M > * >(argp1);
      arg1 = const_cast< Bibor1M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor1M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor1M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor1M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor2M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor2M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor2M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bibor2M *)new Bibor2M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor2M > *smartresult = result ? new ext::shared_ptr<  Bibor2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor2M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bibor2M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bibor2M *)new Bibor2M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor2M > *smartresult = result ? new ext::shared_ptr<  Bibor2M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor2M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor2M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor2M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bibor2M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor2M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor2M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor2M::Bibor2M(Handle< YieldTermStructure > const &)\n"
    "    Bibor2M::Bibor2M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor2M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor2M *arg1 = (Bibor2M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor2M > tempshared1 ;
  ext::shared_ptr< Bibor2M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor2M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor2M" "', argument " "1"" of type '" "Bibor2M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor2M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor2M > * >(argp1);
      arg1 = const_cast< Bibor2M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor2M > * >(argp1);
      arg1 = const_cast< Bibor2M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor2M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor2M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor2M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor3M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor3M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor3M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bibor3M *)new Bibor3M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor3M > *smartresult = result ? new ext::shared_ptr<  Bibor3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor3M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bibor3M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bibor3M *)new Bibor3M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor3M > *smartresult = result ? new ext::shared_ptr<  Bibor3M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor3M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor3M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor3M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bibor3M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor3M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor3M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor3M::Bibor3M(Handle< YieldTermStructure > const &)\n"
    "    Bibor3M::Bibor3M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor3M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor3M *arg1 = (Bibor3M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor3M > tempshared1 ;
  ext::shared_ptr< Bibor3M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor3M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor3M" "', argument " "1"" of type '" "Bibor3M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor3M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor3M > * >(argp1);
      arg1 = const_cast< Bibor3M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor3M > * >(argp1);
      arg1 = const_cast< Bibor3M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor3M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor3M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor3M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor6M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor6M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor6M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bibor6M *)new Bibor6M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor6M > *smartresult = result ? new ext::shared_ptr<  Bibor6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor6M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bibor6M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bibor6M *)new Bibor6M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor6M > *smartresult = result ? new ext::shared_ptr<  Bibor6M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor6M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor6M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor6M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bibor6M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor6M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor6M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor6M::Bibor6M(Handle< YieldTermStructure > const &)\n"
    "    Bibor6M::Bibor6M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor6M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor6M *arg1 = (Bibor6M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor6M > tempshared1 ;
  ext::shared_ptr< Bibor6M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor6M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor6M" "', argument " "1"" of type '" "Bibor6M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor6M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor6M > * >(argp1);
      arg1 = const_cast< Bibor6M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor6M > * >(argp1);
      arg1 = const_cast< Bibor6M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor6M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor6M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor6M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor9M__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor9M *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor9M" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bibor9M *)new Bibor9M((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor9M > *smartresult = result ? new ext::shared_ptr<  Bibor9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor9M__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bibor9M *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bibor9M *)new Bibor9M();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor9M > *smartresult = result ? new ext::shared_ptr<  Bibor9M >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor9M_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor9M(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor9M", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bibor9M__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor9M__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor9M'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor9M::Bibor9M(Handle< YieldTermStructure > const &)\n"
    "    Bibor9M::Bibor9M()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor9M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor9M *arg1 = (Bibor9M *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor9M > tempshared1 ;
  ext::shared_ptr< Bibor9M > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor9M_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor9M" "', argument " "1"" of type '" "Bibor9M *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor9M > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor9M > * >(argp1);
      arg1 = const_cast< Bibor9M * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor9M > * >(argp1);
      arg1 = const_cast< Bibor9M * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor9M_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor9M_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor9M_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bibor1Y__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Bibor1Y *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Bibor1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bibor1Y" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (Bibor1Y *)new Bibor1Y((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor1Y > *smartresult = result ? new ext::shared_ptr<  Bibor1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor1Y__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Bibor1Y *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Bibor1Y *)new Bibor1Y();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bibor1Y > *smartresult = result ? new ext::shared_ptr<  Bibor1Y >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bibor1Y_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bibor1Y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bibor1Y", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Bibor1Y__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Bibor1Y__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bibor1Y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bibor1Y::Bibor1Y(Handle< YieldTermStructure > const &)\n"
    "    Bibor1Y::Bibor1Y()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bibor1Y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bibor1Y *arg1 = (Bibor1Y *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bibor1Y > tempshared1 ;
  ext::shared_ptr< Bibor1Y > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bibor1Y_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bibor1Y" "', argument " "1"" of type '" "Bibor1Y *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bibor1Y > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bibor1Y > * >(argp1);
      arg1 = const_cast< Bibor1Y * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bibor1Y > * >(argp1);
      arg1 = const_cast< Bibor1Y * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bibor1Y_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bibor1Y_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bibor1Y_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DateGeneration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DateGeneration *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DateGeneration", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (DateGeneration *)new DateGeneration();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DateGeneration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DateGeneration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DateGeneration *arg1 = (DateGeneration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DateGeneration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateGeneration" "', argument " "1"" of type '" "DateGeneration *""'"); 
  }
  arg1 = reinterpret_cast< DateGeneration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DateGeneration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DateGeneration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DateGeneration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::optional< BusinessDayConvention > arg4 ;
  SwigValueWrapper< ext::optional< Period > > arg5 ;
  ext::optional< DateGeneration::Rule > arg6 ;
  ext::optional< bool > arg7 ;
  std::vector< bool,std::allocator< bool > > *arg8 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  Schedule *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Schedule" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  
  if(swig_obj[3] == Py_None)
  arg4 = ext::nullopt;
  else if (PyInt_Check(swig_obj[3]))
  arg4 = (BusinessDayConvention) PyInt_AsLong(swig_obj[3]);
  else
  arg4 = (BusinessDayConvention) PyLong_AsLong(swig_obj[3]);
  
  
  if(swig_obj[4] == Py_None) {
    arg5 = ext::nullopt;
  } else {
    void *argp;
    int res = 0;
    // copied from SWIGTYPE typemap -- might need updating for newer SWIG
    res = SWIG_ConvertPtr(swig_obj[4], &argp, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    } else {
      Period p = *reinterpret_cast<Period*>(argp);
      arg5 = (ext::optional<Period>) p;
    }
  }
  
  
  if(swig_obj[5] == Py_None)
  arg6 = ext::nullopt;
  else if (PyInt_Check(swig_obj[5]))
  arg6 = (DateGeneration::Rule) PyInt_AsLong(swig_obj[5]);
  else
  arg6 = (DateGeneration::Rule) PyLong_AsLong(swig_obj[5]);
  
  
  if(swig_obj[6] == Py_None)
  arg7 = ext::nullopt;
  else if (swig_obj[6] == Py_True)
  arg7 = true;
  else
  arg7 = false;
  
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Schedule" "', argument " "8"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "8"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg8 = ptr;
  }
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2,arg3,arg4,arg5,arg6,arg7,(std::vector< bool,std::allocator< bool > > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::optional< BusinessDayConvention > arg4 ;
  SwigValueWrapper< ext::optional< Period > > arg5 ;
  ext::optional< DateGeneration::Rule > arg6 ;
  ext::optional< bool > arg7 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Schedule" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  
  if(swig_obj[3] == Py_None)
  arg4 = ext::nullopt;
  else if (PyInt_Check(swig_obj[3]))
  arg4 = (BusinessDayConvention) PyInt_AsLong(swig_obj[3]);
  else
  arg4 = (BusinessDayConvention) PyLong_AsLong(swig_obj[3]);
  
  
  if(swig_obj[4] == Py_None) {
    arg5 = ext::nullopt;
  } else {
    void *argp;
    int res = 0;
    // copied from SWIGTYPE typemap -- might need updating for newer SWIG
    res = SWIG_ConvertPtr(swig_obj[4], &argp, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    } else {
      Period p = *reinterpret_cast<Period*>(argp);
      arg5 = (ext::optional<Period>) p;
    }
  }
  
  
  if(swig_obj[5] == Py_None)
  arg6 = ext::nullopt;
  else if (PyInt_Check(swig_obj[5]))
  arg6 = (DateGeneration::Rule) PyInt_AsLong(swig_obj[5]);
  else
  arg6 = (DateGeneration::Rule) PyLong_AsLong(swig_obj[5]);
  
  
  if(swig_obj[6] == Py_None)
  arg7 = ext::nullopt;
  else if (swig_obj[6] == Py_True)
  arg7 = true;
  else
  arg7 = false;
  
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::optional< BusinessDayConvention > arg4 ;
  SwigValueWrapper< ext::optional< Period > > arg5 ;
  ext::optional< DateGeneration::Rule > arg6 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Schedule" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  
  if(swig_obj[3] == Py_None)
  arg4 = ext::nullopt;
  else if (PyInt_Check(swig_obj[3]))
  arg4 = (BusinessDayConvention) PyInt_AsLong(swig_obj[3]);
  else
  arg4 = (BusinessDayConvention) PyLong_AsLong(swig_obj[3]);
  
  
  if(swig_obj[4] == Py_None) {
    arg5 = ext::nullopt;
  } else {
    void *argp;
    int res = 0;
    // copied from SWIGTYPE typemap -- might need updating for newer SWIG
    res = SWIG_ConvertPtr(swig_obj[4], &argp, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    } else {
      Period p = *reinterpret_cast<Period*>(argp);
      arg5 = (ext::optional<Period>) p;
    }
  }
  
  
  if(swig_obj[5] == Py_None)
  arg6 = ext::nullopt;
  else if (PyInt_Check(swig_obj[5]))
  arg6 = (DateGeneration::Rule) PyInt_AsLong(swig_obj[5]);
  else
  arg6 = (DateGeneration::Rule) PyLong_AsLong(swig_obj[5]);
  
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::optional< BusinessDayConvention > arg4 ;
  SwigValueWrapper< ext::optional< Period > > arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Schedule" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  
  if(swig_obj[3] == Py_None)
  arg4 = ext::nullopt;
  else if (PyInt_Check(swig_obj[3]))
  arg4 = (BusinessDayConvention) PyInt_AsLong(swig_obj[3]);
  else
  arg4 = (BusinessDayConvention) PyLong_AsLong(swig_obj[3]);
  
  
  if(swig_obj[4] == Py_None) {
    arg5 = ext::nullopt;
  } else {
    void *argp;
    int res = 0;
    // copied from SWIGTYPE typemap -- might need updating for newer SWIG
    res = SWIG_ConvertPtr(swig_obj[4], &argp, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference in method 'new_Schedule', argument 5 of type 'ext::optional< Period >'");
    } else {
      Period p = *reinterpret_cast<Period*>(argp);
      arg5 = (ext::optional<Period>) p;
    }
  }
  
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::optional< BusinessDayConvention > arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Schedule" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  
  if(swig_obj[3] == Py_None)
  arg4 = ext::nullopt;
  else if (PyInt_Check(swig_obj[3]))
  arg4 = (BusinessDayConvention) PyInt_AsLong(swig_obj[3]);
  else
  arg4 = (BusinessDayConvention) PyLong_AsLong(swig_obj[3]);
  
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Schedule" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Schedule *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (Schedule *)new Schedule((std::vector< Date,std::allocator< Date > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  Date *arg10 = 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 val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Schedule" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Schedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Schedule" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Schedule" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Schedule" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Schedule" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Schedule" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_Schedule" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  {
    try {
      result = (Schedule *)new Schedule((Date const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,(Calendar const &)*arg4,arg5,arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Schedule" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Schedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Schedule" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Schedule" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Schedule" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Schedule" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Schedule" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    try {
      result = (Schedule *)new Schedule((Date const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,(Calendar const &)*arg4,arg5,arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  Schedule *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Schedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Schedule" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Schedule" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Schedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Schedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Schedule" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Schedule" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Schedule" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Schedule" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (Schedule *)new Schedule((Date const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,(Calendar const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Schedule *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Schedule *)new Schedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Schedule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Schedule", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Schedule__SWIG_11(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Schedule__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Schedule__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Schedule__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PyInt_Check(argv[3]) || PyLong_Check(argv[3]) || Py_None == argv[3])
            _v = 1;
            else
            _v = 0;
          }
          if (_v) {
            return _wrap_new_Schedule__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PyInt_Check(argv[3]) || PyLong_Check(argv[3]) || Py_None == argv[3])
            _v = 1;
            else
            _v = 0;
          }
          if (_v) {
            {
              if(argv[4] == Py_None) {
                _v = 1;
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              return _wrap_new_Schedule__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PyInt_Check(argv[3]) || PyLong_Check(argv[3]) || Py_None == argv[3])
            _v = 1;
            else
            _v = 0;
          }
          if (_v) {
            {
              if(argv[4] == Py_None) {
                _v = 1;
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              {
                if (PyInt_Check(argv[5]) || PyLong_Check(argv[5]) || Py_None == argv[5])
                _v = 1;
                else
                _v = 0;
              }
              if (_v) {
                return _wrap_new_Schedule__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PyInt_Check(argv[3]) || PyLong_Check(argv[3]) || Py_None == argv[3])
            _v = 1;
            else
            _v = 0;
          }
          if (_v) {
            {
              if(argv[4] == Py_None) {
                _v = 1;
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              {
                if (PyInt_Check(argv[5]) || PyLong_Check(argv[5]) || Py_None == argv[5])
                _v = 1;
                else
                _v = 0;
              }
              if (_v) {
                {
                  if (PyBool_Check(argv[6]) || Py_None == argv[6]) 
                  _v = 1;
                  else
                  _v = 0;
                }
                if (_v) {
                  return _wrap_new_Schedule__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Schedule__SWIG_10(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            if (PyInt_Check(argv[3]) || PyLong_Check(argv[3]) || Py_None == argv[3])
            _v = 1;
            else
            _v = 0;
          }
          if (_v) {
            {
              if(argv[4] == Py_None) {
                _v = 1;
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              {
                if (PyInt_Check(argv[5]) || PyLong_Check(argv[5]) || Py_None == argv[5])
                _v = 1;
                else
                _v = 0;
              }
              if (_v) {
                {
                  if (PyBool_Check(argv[6]) || Py_None == argv[6]) 
                  _v = 1;
                  else
                  _v = 0;
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector<bool,std::allocator< bool > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_Schedule__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_Schedule__SWIG_9(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_Schedule__SWIG_8(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Schedule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,ext::optional< BusinessDayConvention >,ext::optional< Period >,ext::optional< DateGeneration::Rule >,ext::optional< bool >,std::vector< bool,std::allocator< bool > > const &)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,ext::optional< BusinessDayConvention >,ext::optional< Period >,ext::optional< DateGeneration::Rule >,ext::optional< bool >)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,ext::optional< BusinessDayConvention >,ext::optional< Period >,ext::optional< DateGeneration::Rule >)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,ext::optional< BusinessDayConvention >,ext::optional< Period >)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const,ext::optional< BusinessDayConvention >)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &,BusinessDayConvention const)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &,Calendar const &)\n"
    "    Schedule::Schedule(std::vector< Date,std::allocator< Date > > const &)\n"
    "    Schedule::Schedule(Date const &,Date const &,Period const &,Calendar const &,BusinessDayConvention,BusinessDayConvention,DateGeneration::Rule,bool,Date const &,Date const &)\n"
    "    Schedule::Schedule(Date const &,Date const &,Period const &,Calendar const &,BusinessDayConvention,BusinessDayConvention,DateGeneration::Rule,bool,Date const &)\n"
    "    Schedule::Schedule(Date const &,Date const &,Period const &,Calendar const &,BusinessDayConvention,BusinessDayConvention,DateGeneration::Rule,bool)\n"
    "    Schedule::Schedule()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Schedule___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule___len__" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = ((Schedule const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_previousDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Schedule_previousDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_previousDate" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Schedule_previousDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Schedule_previousDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((Schedule const *)arg1)->previousDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_nextDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Schedule_nextDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_nextDate" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Schedule_nextDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Schedule_nextDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((Schedule const *)arg1)->nextDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_dates" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((Schedule const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_hasIsRegular(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_hasIsRegular" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasIsRegular();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_isRegular__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_isRegular" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Schedule_isRegular" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (bool)((Schedule const *)arg1)->isRegular(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_isRegular__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_isRegular" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (std::vector< bool,std::allocator< bool > > *) &((Schedule const *)arg1)->isRegular();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_isRegular(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Schedule_isRegular", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Schedule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Schedule_isRegular__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Schedule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Schedule_isRegular__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Schedule_isRegular'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Schedule::isRegular(Size) const\n"
    "    Schedule::isRegular() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Schedule_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Calendar *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_calendar" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (Calendar *) &((Schedule const *)arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Calendar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_startDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_startDate" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (Date *) &((Schedule const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_endDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_endDate" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (Date *) &((Schedule const *)arg1)->endDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_hasTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_hasTenor" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasTenor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_tenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Period *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_tenor" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (Period *) &((Schedule const *)arg1)->tenor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Period, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_businessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_businessDayConvention" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (BusinessDayConvention)((Schedule const *)arg1)->businessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_hasTerminationDateBusinessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_hasTerminationDateBusinessDayConvention" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasTerminationDateBusinessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_terminationDateBusinessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_terminationDateBusinessDayConvention" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (BusinessDayConvention)((Schedule const *)arg1)->terminationDateBusinessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_hasRule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_hasRule" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasRule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_rule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DateGeneration::Rule result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_rule" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (DateGeneration::Rule)((Schedule const *)arg1)->rule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_hasEndOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_hasEndOfMonth" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (bool)((Schedule const *)arg1)->hasEndOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_endOfMonth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_endOfMonth" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      result = (bool)((Schedule const *)arg1)->endOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_after(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Schedule result;
  
  if (!SWIG_Python_UnpackTuple(args, "Schedule_after", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_after" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Schedule_after" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Schedule_after" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((Schedule const *)arg1)->after((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Schedule(result)), SWIGTYPE_p_Schedule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule_until(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Schedule result;
  
  if (!SWIG_Python_UnpackTuple(args, "Schedule_until", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule_until" "', argument " "1"" of type '" "Schedule const *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Schedule_until" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Schedule_until" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((Schedule const *)arg1)->until((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Schedule(result)), SWIGTYPE_p_Schedule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Schedule___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Schedule___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Schedule___getitem__" "', argument " "1"" of type '" "Schedule *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Schedule___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = Schedule___getitem__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Schedule *arg1 = (Schedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Schedule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Schedule" "', argument " "1"" of type '" "Schedule *""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Schedule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Schedule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Schedule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new__MakeSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new__MakeSchedule", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (MakeSchedule *)new MakeSchedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_fromDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_fromDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_fromDate" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeSchedule_fromDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeSchedule_fromDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->from((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_to", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_to" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeSchedule_to" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeSchedule_to" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->to((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withTenor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withTenor" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeSchedule_withTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeSchedule_withTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withFrequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Frequency arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withFrequency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withFrequency" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeSchedule_withFrequency" "', argument " "2"" of type '" "Frequency""'");
  } 
  arg2 = static_cast< Frequency >(val2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withFrequency(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withCalendar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withCalendar" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeSchedule_withCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeSchedule_withCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withCalendar((Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withConvention", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withConvention" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeSchedule_withConvention" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withConvention(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withTerminationDateConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withTerminationDateConvention", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withTerminationDateConvention" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeSchedule_withTerminationDateConvention" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withTerminationDateConvention(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withRule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  DateGeneration::Rule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withRule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withRule" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeSchedule_withRule" "', argument " "2"" of type '" "DateGeneration::Rule""'");
  } 
  arg2 = static_cast< DateGeneration::Rule >(val2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withRule(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_forwards(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MakeSchedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_forwards" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  {
    try {
      result = (MakeSchedule *) &(arg1)->forwards();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_backwards(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MakeSchedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_backwards" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  {
    try {
      result = (MakeSchedule *) &(arg1)->backwards();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_endOfMonth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeSchedule *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_endOfMonth" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeSchedule_endOfMonth" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->endOfMonth(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_endOfMonth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeSchedule *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_endOfMonth" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  {
    try {
      result = (MakeSchedule *) &(arg1)->endOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_endOfMonth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeSchedule_endOfMonth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeSchedule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeSchedule_endOfMonth__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeSchedule, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeSchedule_endOfMonth__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeSchedule_endOfMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeSchedule::endOfMonth(bool)\n"
    "    MakeSchedule::endOfMonth()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withFirstDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withFirstDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withFirstDate" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeSchedule_withFirstDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeSchedule_withFirstDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withFirstDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_withNextToLastDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeSchedule *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeSchedule_withNextToLastDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_withNextToLastDate" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeSchedule_withNextToLastDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeSchedule_withNextToLastDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeSchedule *) &(arg1)->withNextToLastDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeSchedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeSchedule_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Schedule result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeSchedule_schedule" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  {
    try {
      result = MakeSchedule_schedule(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Schedule(result)), SWIGTYPE_p_Schedule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__MakeSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeSchedule *arg1 = (MakeSchedule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeSchedule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__MakeSchedule" "', argument " "1"" of type '" "MakeSchedule *""'"); 
  }
  arg1 = reinterpret_cast< MakeSchedule * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_MakeSchedule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MakeSchedule, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_MakeSchedule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_VolatilityTermStructure_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VolatilityTermStructure *arg1 = (VolatilityTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VolatilityTermStructure const > tempshared1 ;
  ext::shared_ptr< VolatilityTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VolatilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VolatilityTermStructure_minStrike" "', argument " "1"" of type '" "VolatilityTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const VolatilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const VolatilityTermStructure > * >(argp1);
      arg1 = const_cast< VolatilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const VolatilityTermStructure > * >(argp1);
      arg1 = const_cast< VolatilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((VolatilityTermStructure const *)arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VolatilityTermStructure_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VolatilityTermStructure *arg1 = (VolatilityTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VolatilityTermStructure const > tempshared1 ;
  ext::shared_ptr< VolatilityTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VolatilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VolatilityTermStructure_maxStrike" "', argument " "1"" of type '" "VolatilityTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const VolatilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const VolatilityTermStructure > * >(argp1);
      arg1 = const_cast< VolatilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const VolatilityTermStructure > * >(argp1);
      arg1 = const_cast< VolatilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((VolatilityTermStructure const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VolatilityTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VolatilityTermStructure *arg1 = (VolatilityTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VolatilityTermStructure > tempshared1 ;
  ext::shared_ptr< VolatilityTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VolatilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VolatilityTermStructure" "', argument " "1"" of type '" "VolatilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VolatilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VolatilityTermStructure > * >(argp1);
      arg1 = const_cast< VolatilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VolatilityTermStructure > * >(argp1);
      arg1 = const_cast< VolatilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VolatilityTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VolatilityTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructure_blackVol", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructure_blackVol__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructure_blackVol__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackVol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackVol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructure_blackVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackVol(Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackVol(Date const &,Real) const\n"
    "    BlackVolTermStructure::blackVol(Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackVol(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructure_blackVariance", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructure_blackVariance__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructure_blackVariance__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackVariance__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackVariance__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructure_blackVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackVariance(Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackVariance(Date const &,Real) const\n"
    "    BlackVolTermStructure::blackVariance(Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackVariance(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackForwardVol(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)((BlackVolTermStructure const *)arg1)->blackForwardVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructure_blackForwardVol", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackForwardVol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackForwardVol__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructure_blackForwardVol__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructure_blackForwardVol__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructure_blackForwardVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackForwardVol(Date const &,Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVol(Date const &,Date const &,Real) const\n"
    "    BlackVolTermStructure::blackForwardVol(Time,Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVol(Time,Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackForwardVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure const > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "1"" of type '" "BlackVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructure_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((BlackVolTermStructure const *)arg1)->blackForwardVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructure_blackForwardVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructure_blackForwardVariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackForwardVariance__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructure_blackForwardVariance__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructure_blackForwardVariance__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructure_blackForwardVariance__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructure_blackForwardVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackForwardVariance(Date const &,Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVariance(Date const &,Date const &,Real) const\n"
    "    BlackVolTermStructure::blackForwardVariance(Time,Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVariance(Time,Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackVolTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackVolTermStructure *arg1 = (BlackVolTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempshared1 ;
  ext::shared_ptr< BlackVolTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackVolTermStructure" "', argument " "1"" of type '" "BlackVolTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackVolTermStructure > * >(argp1);
      arg1 = const_cast< BlackVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackVolTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BlackVolTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BlackVolTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempshared1 ;
  Handle< BlackVolTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackVolTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< BlackVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< BlackVolTermStructure > *)new Handle< BlackVolTermStructure >((ext::shared_ptr< BlackVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackVolTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< BlackVolTermStructure > *)new Handle< BlackVolTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackVolTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackVolTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BlackVolTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BlackVolTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackVolTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< BlackVolTermStructure >::Handle(ext::shared_ptr< BlackVolTermStructure > const &)\n"
    "    Handle< BlackVolTermStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< BlackVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle___deref__" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackVolTermStructure > *smartresult = result ? new ext::shared_ptr<  BlackVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< BlackVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackVolTermStructure > *smartresult = result ? new ext::shared_ptr<  BlackVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_BlackVolTermStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle___bool__" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_BlackVolTermStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_BlackVolTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackVolTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackVolTermStructureHandle" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->blackVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->blackVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->blackVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->blackVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructureHandle_blackVol", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructureHandle_blackVol__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructureHandle_blackVol__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackVol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackVol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructureHandle_blackVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackVol(Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackVol(Date const &,Real) const\n"
    "    BlackVolTermStructure::blackVol(Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackVol(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackVariance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructureHandle_blackVariance", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructureHandle_blackVariance__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackVolTermStructureHandle_blackVariance__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackVariance__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackVariance__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructureHandle_blackVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackVariance(Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackVariance(Date const &,Real) const\n"
    "    BlackVolTermStructure::blackVariance(Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackVariance(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)(*arg1)->blackForwardVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructureHandle_blackForwardVol", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructureHandle_blackForwardVol__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructureHandle_blackForwardVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackForwardVol(Date const &,Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVol(Date const &,Date const &,Real) const\n"
    "    BlackVolTermStructure::blackForwardVol(Time,Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVol(Time,Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackVolTermStructureHandle_blackForwardVariance" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)(*arg1)->blackForwardVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_blackForwardVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVolTermStructureHandle_blackForwardVariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BlackVolTermStructureHandle_blackForwardVariance__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVolTermStructureHandle_blackForwardVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVolTermStructure::blackForwardVariance(Date const &,Date const &,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVariance(Date const &,Date const &,Real) const\n"
    "    BlackVolTermStructure::blackForwardVariance(Time,Time,Real,bool) const\n"
    "    BlackVolTermStructure::blackForwardVariance(Time,Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_minStrike" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_maxStrike" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackVolTermStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVolTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVolTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_calendar" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVolTermStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = (Handle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVolTermStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackVolTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackVolTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableBlackVolTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BlackVolTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempshared1 ;
  RelinkableHandle< BlackVolTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableBlackVolTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< BlackVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< BlackVolTermStructure > *)new RelinkableHandle< BlackVolTermStructure >((ext::shared_ptr< BlackVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableBlackVolTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< BlackVolTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< BlackVolTermStructure > *)new RelinkableHandle< BlackVolTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableBlackVolTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableBlackVolTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableBlackVolTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableBlackVolTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableBlackVolTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< BlackVolTermStructure >::RelinkableHandle(ext::shared_ptr< BlackVolTermStructure > const &)\n"
    "    RelinkableHandle< BlackVolTermStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableBlackVolTermStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< BlackVolTermStructure > *arg1 = (RelinkableHandle< BlackVolTermStructure > *) 0 ;
  ext::shared_ptr< BlackVolTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableBlackVolTermStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableBlackVolTermStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< BlackVolTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableBlackVolTermStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< BlackVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< BlackVolTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableBlackVolTermStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< BlackVolTermStructure > *arg1 = (RelinkableHandle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableBlackVolTermStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< BlackVolTermStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_BlackVolTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableBlackVolTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< BlackVolTermStructure > *arg1 = (RelinkableHandle< BlackVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableBlackVolTermStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< BlackVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< BlackVolTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableBlackVolTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_BlackVolTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableBlackVolTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_LocalVolTermStructure_localVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure const > tempshared1 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructure_localVol" "', argument " "1"" of type '" "LocalVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalVolTermStructure_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalVolTermStructure_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructure_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LocalVolTermStructure_localVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)arg1)->localVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructure_localVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure const > tempshared1 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructure_localVol" "', argument " "1"" of type '" "LocalVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalVolTermStructure_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalVolTermStructure_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructure_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)arg1)->localVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructure_localVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure const > tempshared1 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructure_localVol" "', argument " "1"" of type '" "LocalVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalVolTermStructure_localVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructure_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LocalVolTermStructure_localVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)arg1)->localVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructure_localVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure const > tempshared1 ;
  ext::shared_ptr< LocalVolTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructure_localVol" "', argument " "1"" of type '" "LocalVolTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalVolTermStructure_localVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructure_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((LocalVolTermStructure const *)arg1)->localVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructure_localVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LocalVolTermStructure_localVol", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LocalVolTermStructure_localVol__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LocalVolTermStructure_localVol__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LocalVolTermStructure_localVol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LocalVolTermStructure_localVol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LocalVolTermStructure_localVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LocalVolTermStructure::localVol(Date const &,Real,bool) const\n"
    "    LocalVolTermStructure::localVol(Date const &,Real) const\n"
    "    LocalVolTermStructure::localVol(Time,Real,bool) const\n"
    "    LocalVolTermStructure::localVol(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocalVolTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LocalVolTermStructure *arg1 = (LocalVolTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  ext::shared_ptr< LocalVolTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalVolTermStructure" "', argument " "1"" of type '" "LocalVolTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LocalVolTermStructure > * >(argp1);
      arg1 = const_cast< LocalVolTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocalVolTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LocalVolTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  Handle< LocalVolTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalVolTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< LocalVolTermStructure > *)new Handle< LocalVolTermStructure >((ext::shared_ptr< LocalVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_LocalVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalVolTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< LocalVolTermStructure > *)new Handle< LocalVolTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_LocalVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalVolTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalVolTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LocalVolTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocalVolTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalVolTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< LocalVolTermStructure >::Handle(ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    Handle< LocalVolTermStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle___deref__" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolTermStructure > *smartresult = result ? new ext::shared_ptr<  LocalVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolTermStructure > *smartresult = result ? new ext::shared_ptr<  LocalVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_LocalVolTermStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle___bool__" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_LocalVolTermStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_LocalVolTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LocalVolTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalVolTermStructureHandle" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_localVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->localVol((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_localVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->localVol((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_localVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->localVol(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_localVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalVolTermStructureHandle_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->localVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_localVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LocalVolTermStructureHandle_localVol", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LocalVolTermStructureHandle_localVol__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LocalVolTermStructureHandle_localVol__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LocalVolTermStructureHandle_localVol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LocalVolTermStructureHandle_localVol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LocalVolTermStructureHandle_localVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LocalVolTermStructure::localVol(Date const &,Real,bool) const\n"
    "    LocalVolTermStructure::localVol(Date const &,Real) const\n"
    "    LocalVolTermStructure::localVol(Time,Real,bool) const\n"
    "    LocalVolTermStructure::localVol(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_minStrike" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_maxStrike" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "LocalVolTermStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalVolTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalVolTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_calendar" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolTermStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< LocalVolTermStructure > *arg1 = (Handle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolTermStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocalVolTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_LocalVolTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LocalVolTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableLocalVolTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  RelinkableHandle< LocalVolTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableLocalVolTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< LocalVolTermStructure > *)new RelinkableHandle< LocalVolTermStructure >((ext::shared_ptr< LocalVolTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableLocalVolTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< LocalVolTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< LocalVolTermStructure > *)new RelinkableHandle< LocalVolTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableLocalVolTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableLocalVolTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableLocalVolTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableLocalVolTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableLocalVolTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< LocalVolTermStructure >::RelinkableHandle(ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    RelinkableHandle< LocalVolTermStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableLocalVolTermStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< LocalVolTermStructure > *arg1 = (RelinkableHandle< LocalVolTermStructure > *) 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableLocalVolTermStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableLocalVolTermStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< LocalVolTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableLocalVolTermStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< LocalVolTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableLocalVolTermStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< LocalVolTermStructure > *arg1 = (RelinkableHandle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableLocalVolTermStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< LocalVolTermStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_LocalVolTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableLocalVolTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< LocalVolTermStructure > *arg1 = (RelinkableHandle< LocalVolTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableLocalVolTermStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< LocalVolTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< LocalVolTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableLocalVolTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_LocalVolTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableLocalVolTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((OptionletVolatilityStructure const *)arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OptionletVolatilityStructure_volatility", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructure_volatility__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructure_volatility__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructure_volatility__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructure_volatility__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OptionletVolatilityStructure_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OptionletVolatilityStructure::volatility(Date const &,Real,bool) const\n"
    "    OptionletVolatilityStructure::volatility(Date const &,Real) const\n"
    "    OptionletVolatilityStructure::volatility(Time,Real,bool) const\n"
    "    OptionletVolatilityStructure::volatility(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_blackVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_blackVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_blackVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_blackVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "1"" of type '" "OptionletVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((OptionletVolatilityStructure const *)arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructure_blackVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OptionletVolatilityStructure_blackVariance", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructure_blackVariance__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructure_blackVariance__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructure_blackVariance__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructure_blackVariance__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OptionletVolatilityStructure_blackVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OptionletVolatilityStructure::blackVariance(Date const &,Rate,bool) const\n"
    "    OptionletVolatilityStructure::blackVariance(Date const &,Rate) const\n"
    "    OptionletVolatilityStructure::blackVariance(Time,Rate,bool) const\n"
    "    OptionletVolatilityStructure::blackVariance(Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OptionletVolatilityStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptionletVolatilityStructure *arg1 = (OptionletVolatilityStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempshared1 ;
  ext::shared_ptr< OptionletVolatilityStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptionletVolatilityStructure" "', argument " "1"" of type '" "OptionletVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OptionletVolatilityStructure > * >(argp1);
      arg1 = const_cast< OptionletVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptionletVolatilityStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OptionletVolatilityStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OptionletVolatilityStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempshared1 ;
  Handle< OptionletVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptionletVolatilityStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< OptionletVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< OptionletVolatilityStructure > *)new Handle< OptionletVolatilityStructure >((ext::shared_ptr< OptionletVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptionletVolatilityStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< OptionletVolatilityStructure > *)new Handle< OptionletVolatilityStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptionletVolatilityStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OptionletVolatilityStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_OptionletVolatilityStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptionletVolatilityStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OptionletVolatilityStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< OptionletVolatilityStructure >::Handle(ext::shared_ptr< OptionletVolatilityStructure > const &)\n"
    "    Handle< OptionletVolatilityStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OptionletVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle___deref__" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OptionletVolatilityStructure > *smartresult = result ? new ext::shared_ptr<  OptionletVolatilityStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OptionletVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OptionletVolatilityStructure > *smartresult = result ? new ext::shared_ptr<  OptionletVolatilityStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_OptionletVolatilityStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle___bool__" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_OptionletVolatilityStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_OptionletVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OptionletVolatilityStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptionletVolatilityStructureHandle" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OptionletVolatilityStructureHandle_volatility", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructureHandle_volatility__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructureHandle_volatility__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructureHandle_volatility__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructureHandle_volatility__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OptionletVolatilityStructureHandle_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OptionletVolatilityStructure::volatility(Date const &,Real,bool) const\n"
    "    OptionletVolatilityStructure::volatility(Date const &,Real) const\n"
    "    OptionletVolatilityStructure::volatility(Time,Real,bool) const\n"
    "    OptionletVolatilityStructure::volatility(Time,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OptionletVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_blackVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OptionletVolatilityStructureHandle_blackVariance", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OptionletVolatilityStructureHandle_blackVariance__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OptionletVolatilityStructureHandle_blackVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OptionletVolatilityStructure::blackVariance(Date const &,Rate,bool) const\n"
    "    OptionletVolatilityStructure::blackVariance(Date const &,Rate) const\n"
    "    OptionletVolatilityStructure::blackVariance(Time,Rate,bool) const\n"
    "    OptionletVolatilityStructure::blackVariance(Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_minStrike" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_maxStrike" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "OptionletVolatilityStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptionletVolatilityStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptionletVolatilityStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_calendar" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletVolatilityStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletVolatilityStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptionletVolatilityStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OptionletVolatilityStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableOptionletVolatilityStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OptionletVolatilityStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempshared1 ;
  RelinkableHandle< OptionletVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableOptionletVolatilityStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< OptionletVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< OptionletVolatilityStructure > *)new RelinkableHandle< OptionletVolatilityStructure >((ext::shared_ptr< OptionletVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableOptionletVolatilityStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< OptionletVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< OptionletVolatilityStructure > *)new RelinkableHandle< OptionletVolatilityStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableOptionletVolatilityStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableOptionletVolatilityStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableOptionletVolatilityStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableOptionletVolatilityStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableOptionletVolatilityStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< OptionletVolatilityStructure >::RelinkableHandle(ext::shared_ptr< OptionletVolatilityStructure > const &)\n"
    "    RelinkableHandle< OptionletVolatilityStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableOptionletVolatilityStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< OptionletVolatilityStructure > *arg1 = (RelinkableHandle< OptionletVolatilityStructure > *) 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< OptionletVolatilityStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableOptionletVolatilityStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableOptionletVolatilityStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< OptionletVolatilityStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_OptionletVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableOptionletVolatilityStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< OptionletVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< OptionletVolatilityStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableOptionletVolatilityStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< OptionletVolatilityStructure > *arg1 = (RelinkableHandle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableOptionletVolatilityStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_OptionletVolatilityStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableOptionletVolatilityStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< OptionletVolatilityStructure > *arg1 = (RelinkableHandle< OptionletVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableOptionletVolatilityStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< OptionletVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< OptionletVolatilityStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableOptionletVolatilityStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_OptionletVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableOptionletVolatilityStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_observationLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_observationLag" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYOptionletVolatilitySurface const *)arg1)->observationLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_frequency" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_indexIsInterpolated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_indexIsInterpolated" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((YoYOptionletVolatilitySurface const *)arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_baseDate" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYOptionletVolatilitySurface const *)arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_timeFromBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Time result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Time)((YoYOptionletVolatilitySurface const *)arg1)->timeFromBase((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_timeFromBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Time result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)((YoYOptionletVolatilitySurface const *)arg1)->timeFromBase((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_timeFromBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurface_timeFromBase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYOptionletVolatilitySurface_timeFromBase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurface_timeFromBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionletVolatilitySurface_timeFromBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYOptionletVolatilitySurface::timeFromBase(Date const &,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::timeFromBase(Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_minStrike" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_maxStrike" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_baseLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Volatility result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_baseLevel" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->baseLevel();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Date const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Date const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Period const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Period const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((YoYOptionletVolatilitySurface const *)arg1)->volatility((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurface_volatility", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurface_volatility__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurface_volatility__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurface_volatility__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurface_volatility__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurface_volatility__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurface_volatility__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionletVolatilitySurface_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYOptionletVolatilitySurface::volatility(Date const &,Real,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Date const &,Real,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Date const &,Real) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Period const &,Real,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Period const &,Real,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Period const &,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Date const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Date const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Period const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Period const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurface_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((YoYOptionletVolatilitySurface const *)arg1)->totalVariance((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurface_totalVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurface_totalVariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurface_totalVariance__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionletVolatilitySurface_totalVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Date const &,Rate,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Date const &,Rate,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Date const &,Rate) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Period const &,Rate,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Period const &,Rate,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Period const &,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YoYOptionletVolatilitySurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletVolatilitySurface *arg1 = (YoYOptionletVolatilitySurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempshared1 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYOptionletVolatilitySurface" "', argument " "1"" of type '" "YoYOptionletVolatilitySurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = const_cast< YoYOptionletVolatilitySurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYOptionletVolatilitySurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YoYOptionletVolatilitySurfaceHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempshared1 ;
  Handle< YoYOptionletVolatilitySurface > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYOptionletVolatilitySurfaceHandle" "', argument " "1"" of type '" "ext::shared_ptr< YoYOptionletVolatilitySurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< YoYOptionletVolatilitySurface > *)new Handle< YoYOptionletVolatilitySurface >((ext::shared_ptr< YoYOptionletVolatilitySurface > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionletVolatilitySurfaceHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< YoYOptionletVolatilitySurface > *)new Handle< YoYOptionletVolatilitySurface >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionletVolatilitySurfaceHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYOptionletVolatilitySurfaceHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_YoYOptionletVolatilitySurfaceHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YoYOptionletVolatilitySurfaceHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYOptionletVolatilitySurfaceHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< YoYOptionletVolatilitySurface >::Handle(ext::shared_ptr< YoYOptionletVolatilitySurface > const &)\n"
    "    Handle< YoYOptionletVolatilitySurface >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle___deref__" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYOptionletVolatilitySurface > *smartresult = result ? new ext::shared_ptr<  YoYOptionletVolatilitySurface >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_currentLink" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYOptionletVolatilitySurface > *smartresult = result ? new ext::shared_ptr<  YoYOptionletVolatilitySurface >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle___nonzero__" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_YoYOptionletVolatilitySurface_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle___bool__" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_YoYOptionletVolatilitySurface_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_asObservable" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = Handle_Sl_YoYOptionletVolatilitySurface_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYOptionletVolatilitySurfaceHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYOptionletVolatilitySurfaceHandle" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_observationLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_observationLag" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_frequency" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_baseDate" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Time result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Time)(*arg1)->timeFromBase((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Time result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromBase" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromBase((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurfaceHandle_timeFromBase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionletVolatilitySurfaceHandle_timeFromBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYOptionletVolatilitySurface::timeFromBase(Date const &,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::timeFromBase(Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_minStrike" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_maxStrike" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_baseLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Volatility result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_baseLevel" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (Volatility)(*arg1)->baseLevel();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_volatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurfaceHandle_volatility", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurfaceHandle_volatility__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionletVolatilitySurfaceHandle_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYOptionletVolatilitySurface::volatility(Date const &,Real,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Date const &,Real,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Date const &,Real) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Period const &,Real,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Period const &,Real,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::volatility(Period const &,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)(*arg1)->totalVariance((Date const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Real)(*arg1)->totalVariance((Date const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(*arg1)->totalVariance((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)(*arg1)->totalVariance((Period const &)*arg2,arg3,(Period const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (Real)(*arg1)->totalVariance((Period const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionletVolatilitySurfaceHandle_totalVariance" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(*arg1)->totalVariance((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurfaceHandle_totalVariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionletVolatilitySurfaceHandle_totalVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Date const &,Rate,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Date const &,Rate,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Date const &,Rate) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Period const &,Rate,Period const &,bool) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Period const &,Rate,Period const &) const\n"
    "    YoYOptionletVolatilitySurface::totalVariance(Period const &,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_dayCounter" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionletVolatilitySurfaceHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromReference" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletVolatilitySurfaceHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_calendar" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_referenceDate" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_maxDate" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_maxTime" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = (Handle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYOptionletVolatilitySurfaceHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYOptionletVolatilitySurfaceHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableYoYOptionletVolatilitySurfaceHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempshared1 ;
  RelinkableHandle< YoYOptionletVolatilitySurface > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableYoYOptionletVolatilitySurfaceHandle" "', argument " "1"" of type '" "ext::shared_ptr< YoYOptionletVolatilitySurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< YoYOptionletVolatilitySurface > *)new RelinkableHandle< YoYOptionletVolatilitySurface >((ext::shared_ptr< YoYOptionletVolatilitySurface > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableYoYOptionletVolatilitySurfaceHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYOptionletVolatilitySurface > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< YoYOptionletVolatilitySurface > *)new RelinkableHandle< YoYOptionletVolatilitySurface >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableYoYOptionletVolatilitySurfaceHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableYoYOptionletVolatilitySurfaceHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableYoYOptionletVolatilitySurfaceHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableYoYOptionletVolatilitySurfaceHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableYoYOptionletVolatilitySurfaceHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< YoYOptionletVolatilitySurface >::RelinkableHandle(ext::shared_ptr< YoYOptionletVolatilitySurface > const &)\n"
    "    RelinkableHandle< YoYOptionletVolatilitySurface >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYOptionletVolatilitySurface > *arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *) 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YoYOptionletVolatilitySurface > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< YoYOptionletVolatilitySurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YoYOptionletVolatilitySurface > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< YoYOptionletVolatilitySurface > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableYoYOptionletVolatilitySurfaceHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYOptionletVolatilitySurface > *arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableYoYOptionletVolatilitySurfaceHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_YoYOptionletVolatilitySurface_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableYoYOptionletVolatilitySurfaceHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYOptionletVolatilitySurface > *arg1 = (RelinkableHandle< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableYoYOptionletVolatilitySurfaceHandle" "', argument " "1"" of type '" "RelinkableHandle< YoYOptionletVolatilitySurface > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YoYOptionletVolatilitySurface > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableYoYOptionletVolatilitySurfaceHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_YoYOptionletVolatilitySurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableYoYOptionletVolatilitySurfaceHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SmileSection_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_minStrike" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SmileSection const *)arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_maxStrike" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SmileSection const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_atmLevel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_atmLevel" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SmileSection const *)arg1)->atmLevel();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSection_variance", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_variance" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_variance" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->variance(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Volatility result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_volatility" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_volatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Volatility)((SmileSection const *)arg1)->volatility(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_exerciseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_exerciseDate" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Date *) &((SmileSection const *)arg1)->exerciseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_volatilityType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  VolatilityType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_volatilityType" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (VolatilityType)((SmileSection const *)arg1)->volatilityType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_shift(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_shift" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((SmileSection const *)arg1)->shift();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_referenceDate" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Date *) &((SmileSection const *)arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_exerciseTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_exerciseTime" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Time)((SmileSection const *)arg1)->exerciseTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection > tempshared1 ;
  ext::shared_ptr< SmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_dayCounter" "', argument " "1"" of type '" "SmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &(arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_optionPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_optionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_optionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_optionPrice" "', argument " "3"" of type '" "Option::Type""'");
  } 
  arg3 = static_cast< Option::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SmileSection_optionPrice" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->optionPrice(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_optionPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_optionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_optionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_optionPrice" "', argument " "3"" of type '" "Option::Type""'");
  } 
  arg3 = static_cast< Option::Type >(val3);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->optionPrice(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_optionPrice__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_optionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_optionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->optionPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_optionPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSection_optionPrice", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSection_optionPrice__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SmileSection_optionPrice__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SmileSection_optionPrice__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSection_optionPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SmileSection::optionPrice(Rate,Option::Type,Real) const\n"
    "    SmileSection::optionPrice(Rate,Option::Type) const\n"
    "    SmileSection::optionPrice(Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSection_digitalOptionPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_digitalOptionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_digitalOptionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_digitalOptionPrice" "', argument " "3"" of type '" "Option::Type""'");
  } 
  arg3 = static_cast< Option::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SmileSection_digitalOptionPrice" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SmileSection_digitalOptionPrice" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_digitalOptionPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_digitalOptionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_digitalOptionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_digitalOptionPrice" "', argument " "3"" of type '" "Option::Type""'");
  } 
  arg3 = static_cast< Option::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SmileSection_digitalOptionPrice" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_digitalOptionPrice__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Option::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_digitalOptionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_digitalOptionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_digitalOptionPrice" "', argument " "3"" of type '" "Option::Type""'");
  } 
  arg3 = static_cast< Option::Type >(val3);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_digitalOptionPrice__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_digitalOptionPrice" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_digitalOptionPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->digitalOptionPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_digitalOptionPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSection_digitalOptionPrice", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSection_digitalOptionPrice__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SmileSection_digitalOptionPrice__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SmileSection_digitalOptionPrice__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SmileSection_digitalOptionPrice__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSection_digitalOptionPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SmileSection::digitalOptionPrice(Rate,Option::Type,Real,Real) const\n"
    "    SmileSection::digitalOptionPrice(Rate,Option::Type,Real) const\n"
    "    SmileSection::digitalOptionPrice(Rate,Option::Type) const\n"
    "    SmileSection::digitalOptionPrice(Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSection_vega__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_vega" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_vega" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_vega" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->vega(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_vega__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_vega" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_vega" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->vega(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_vega(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSection_vega", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSection_vega__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SmileSection_vega__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSection_vega'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SmileSection::vega(Rate,Real) const\n"
    "    SmileSection::vega(Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSection_density__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_density" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_density" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_density" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SmileSection_density" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->density(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_density__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_density" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_density" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_density" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->density(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_density__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_density" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_density" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((SmileSection const *)arg1)->density(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_density(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSection_density", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSection_density__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SmileSection_density__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SmileSection_density__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSection_density'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SmileSection::density(Rate,Real,Real) const\n"
    "    SmileSection::density(Rate,Real) const\n"
    "    SmileSection::density(Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSection_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  VolatilityType arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_volatility" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_volatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_volatility" "', argument " "3"" of type '" "VolatilityType""'");
  } 
  arg3 = static_cast< VolatilityType >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SmileSection_volatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)((SmileSection const *)arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  Rate arg2 ;
  VolatilityType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection const > tempshared1 ;
  ext::shared_ptr< SmileSection const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSection_volatility" "', argument " "1"" of type '" "SmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSection_volatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSection_volatility" "', argument " "3"" of type '" "VolatilityType""'");
  } 
  arg3 = static_cast< VolatilityType >(val3);
  {
    try {
      result = (Volatility)((SmileSection const *)arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSection_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSection_volatility", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSection_volatility__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SmileSection_volatility__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SmileSection_volatility__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSection_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SmileSection::volatility(Rate) const\n"
    "    SmileSection::volatility(Rate,VolatilityType,Real) const\n"
    "    SmileSection::volatility(Rate,VolatilityType) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SmileSection *arg1 = (SmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SmileSection > tempshared1 ;
  ext::shared_ptr< SmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SmileSection" "', argument " "1"" of type '" "SmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SmileSection > * >(argp1);
      arg1 = const_cast< SmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SmileSectionVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< SmileSection > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____bool__((std::vector< ext::shared_ptr< SmileSection > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____len__((std::vector< ext::shared_ptr< SmileSection > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSectionVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSectionVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSectionVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *ptr = (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SmileSectionVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SmileSectionVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SmileSectionVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SmileSectionVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__setslice__(std::vector< ext::shared_ptr< SmileSection > >::difference_type,std::vector< ext::shared_ptr< SmileSection > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__setslice__(std::vector< ext::shared_ptr< SmileSection > >::difference_type,std::vector< ext::shared_ptr< SmileSection > >::difference_type,std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSectionVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *)std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *ptr = (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SmileSectionVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SmileSectionVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SmileSectionVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSectionVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__delitem__(std::vector< ext::shared_ptr< SmileSection > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< SmileSection > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< SmileSection > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = *result ? new ext::shared_ptr<  SmileSection >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< SmileSection > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SmileSectionVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSectionVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__getitem__(std::vector< ext::shared_ptr< SmileSection > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SmileSectionVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< SmileSection > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SmileSectionVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SmileSectionVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SmileSectionVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > const &)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::__setitem__(std::vector< ext::shared_ptr< SmileSection > >::difference_type,std::vector< ext::shared_ptr< SmileSection > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SmileSectionVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__append(arg1,(ext::shared_ptr< SmileSection > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SmileSectionVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > > *)new std::vector< ext::shared_ptr< SmileSection > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SmileSectionVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *ptr = (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SmileSectionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SmileSectionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > > *)new std::vector< ext::shared_ptr< SmileSection > >((std::vector< ext::shared_ptr< SmileSection > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< SmileSection > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< SmileSection > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SmileSectionVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SmileSectionVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< SmileSection > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< SmileSection > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< SmileSection > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_SmileSection_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SmileSectionVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SmileSectionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > > *)new std::vector< ext::shared_ptr< SmileSection > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_SmileSectionVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_SmileSectionVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::erase(std::vector< ext::shared_ptr< SmileSection > >::iterator)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::erase(std::vector< ext::shared_ptr< SmileSection > >::iterator,std::vector< ext::shared_ptr< SmileSection > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SmileSectionVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg1 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< SmileSection > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SmileSectionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SmileSectionVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > > *)new std::vector< ext::shared_ptr< SmileSection > >(arg1,(std::vector< ext::shared_ptr< SmileSection > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SmileSectionVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SmileSectionVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SmileSectionVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SmileSectionVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SmileSectionVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SmileSectionVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SmileSectionVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::vector()\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::vector(std::vector< ext::shared_ptr< SmileSection > > const &)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::vector(std::vector< ext::shared_ptr< SmileSection > >::size_type)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::vector(std::vector< ext::shared_ptr< SmileSection > >::size_type,std::vector< ext::shared_ptr< SmileSection > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SmileSectionVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< SmileSection > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > >::value_type *) &((std::vector< ext::shared_ptr< SmileSection > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = *result ? new ext::shared_ptr<  SmileSection >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< SmileSection > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< SmileSection > >::value_type *) &((std::vector< ext::shared_ptr< SmileSection > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = *result ? new ext::shared_ptr<  SmileSection >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< SmileSection > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SmileSectionVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< SmileSection > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SmileSectionVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< SmileSection > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SmileSectionVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SmileSectionVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::resize(std::vector< ext::shared_ptr< SmileSection > >::size_type)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::resize(std::vector< ext::shared_ptr< SmileSection > >::size_type,std::vector< ext::shared_ptr< SmileSection > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SmileSectionVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< SmileSection > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< SmileSection > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::iterator arg2 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg3 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SmileSectionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SmileSectionVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SmileSectionVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_SmileSection_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< SmileSection > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SmileSectionVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SmileSectionVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< SmileSection >,std::allocator< ext::shared_ptr< SmileSection > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< SmileSection > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SmileSectionVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SmileSectionVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::insert(std::vector< ext::shared_ptr< SmileSection > >::iterator,std::vector< ext::shared_ptr< SmileSection > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< SmileSection > >::insert(std::vector< ext::shared_ptr< SmileSection > >::iterator,std::vector< ext::shared_ptr< SmileSection > >::size_type,std::vector< ext::shared_ptr< SmileSection > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SmileSectionVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SmileSectionVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SmileSection > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< SmileSection > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SmileSectionVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< SmileSection > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmileSectionVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< SmileSection > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SmileSectionVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< SmileSection > > *arg1 = (std::vector< ext::shared_ptr< SmileSection > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SmileSectionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< SmileSection > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< SmileSection > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SmileSectionVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_SmileSection_t_std__allocatorT_ext__shared_ptrT_SmileSection_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SmileSectionVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)arg1)->volatility(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Volatility)((SwaptionVolatilityStructure const *)arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructure_volatility", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_volatility__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_volatility__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructure_volatility__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructure_volatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructure_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::volatility(Date const &,Period const &,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::volatility(Date const &,Period const &,Rate) const\n"
    "    SwaptionVolatilityStructure::volatility(Time,Time,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::volatility(Time,Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_blackVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_blackVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_blackVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->blackVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_blackVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_blackVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructure_blackVariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_blackVariance__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_blackVariance__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructure_blackVariance__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructure_blackVariance__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructure_blackVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::blackVariance(Date const &,Period const &,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::blackVariance(Date const &,Period const &,Rate) const\n"
    "    SwaptionVolatilityStructure::blackVariance(Time,Time,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::blackVariance(Time,Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_optionDateFromTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructure_optionDateFromTenor", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_optionDateFromTenor" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_optionDateFromTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_optionDateFromTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->optionDateFromTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Period const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Period const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((SwaptionVolatilityStructure const *)arg1)->shift(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_shift(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructure_shift", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_shift__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_shift__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_shift__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_shift__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_shift__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_shift__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_shift__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_shift__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_shift__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_shift__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_shift__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_shift__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructure_shift'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Period const &) const\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Time) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Time) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Time,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Period const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Period const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "1"" of type '" "SwaptionVolatilityStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructure_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((SwaptionVolatilityStructure const *)arg1)->smileSection(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructure_smileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructure_smileSection", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructure_smileSection__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructure_smileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Period const &) const\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Time) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Time) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Time,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolatilityStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityStructure *arg1 = (SwaptionVolatilityStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolatilityStructure" "', argument " "1"" of type '" "SwaptionVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityStructure > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwaptionVolatilityStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SwaptionVolatilityStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempshared1 ;
  Handle< SwaptionVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< SwaptionVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< SwaptionVolatilityStructure > *)new Handle< SwaptionVolatilityStructure >((ext::shared_ptr< SwaptionVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< SwaptionVolatilityStructure > *)new Handle< SwaptionVolatilityStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwaptionVolatilityStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SwaptionVolatilityStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SwaptionVolatilityStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwaptionVolatilityStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< SwaptionVolatilityStructure >::Handle(ext::shared_ptr< SwaptionVolatilityStructure > const &)\n"
    "    Handle< SwaptionVolatilityStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwaptionVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle___deref__" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityStructure > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwaptionVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityStructure > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_SwaptionVolatilityStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle___bool__" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_SwaptionVolatilityStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_SwaptionVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolatilityStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolatilityStructureHandle" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructureHandle_volatility", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructureHandle_volatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructureHandle_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::volatility(Date const &,Period const &,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::volatility(Date const &,Period const &,Rate) const\n"
    "    SwaptionVolatilityStructure::volatility(Time,Time,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::volatility(Time,Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)(*arg1)->blackVariance((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_blackVariance" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)(*arg1)->blackVariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_blackVariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructureHandle_blackVariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SwaptionVolatilityStructureHandle_blackVariance__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructureHandle_blackVariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::blackVariance(Date const &,Period const &,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::blackVariance(Date const &,Period const &,Rate) const\n"
    "    SwaptionVolatilityStructure::blackVariance(Time,Time,Rate,bool) const\n"
    "    SwaptionVolatilityStructure::blackVariance(Time,Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_optionDateFromTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructureHandle_optionDateFromTenor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_optionDateFromTenor" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_optionDateFromTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_optionDateFromTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (*arg1)->optionDateFromTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->shift((Period const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)(*arg1)->shift((Period const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->shift((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)(*arg1)->shift((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->shift(arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)(*arg1)->shift(arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->shift((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(*arg1)->shift((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->shift((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(*arg1)->shift((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Real)(*arg1)->shift(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_shift" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(*arg1)->shift(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_shift(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructureHandle_shift", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_shift__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructureHandle_shift'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Period const &) const\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Period const &,Time) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Date const &,Time) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Time,bool) const\n"
    "    SwaptionVolatilityStructure::shift(Time,Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (*arg1)->smileSection((Period const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (*arg1)->smileSection((Period const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (*arg1)->smileSection((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (*arg1)->smileSection((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (*arg1)->smileSection(arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (*arg1)->smileSection(arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (*arg1)->smileSection((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (*arg1)->smileSection((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (*arg1)->smileSection((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (*arg1)->smileSection((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (*arg1)->smileSection(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityStructureHandle_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (*arg1)->smileSection(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SmileSection > *smartresult = result ? new ext::shared_ptr<  SmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_smileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructureHandle_smileSection", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_9(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SwaptionVolatilityStructureHandle_smileSection__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityStructureHandle_smileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Period const &) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Period const &,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Period const &) const\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Period const &,Time) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Time,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Date const &,Time) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Time,bool) const\n"
    "    SwaptionVolatilityStructure::smileSection(Time,Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_minStrike" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_maxStrike" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwaptionVolatilityStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_calendar" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = (Handle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwaptionVolatilityStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwaptionVolatilityStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableSwaptionVolatilityStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SwaptionVolatilityStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempshared1 ;
  RelinkableHandle< SwaptionVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableSwaptionVolatilityStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< SwaptionVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< SwaptionVolatilityStructure > *)new RelinkableHandle< SwaptionVolatilityStructure >((ext::shared_ptr< SwaptionVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableSwaptionVolatilityStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< SwaptionVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< SwaptionVolatilityStructure > *)new RelinkableHandle< SwaptionVolatilityStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableSwaptionVolatilityStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableSwaptionVolatilityStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableSwaptionVolatilityStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableSwaptionVolatilityStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableSwaptionVolatilityStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< SwaptionVolatilityStructure >::RelinkableHandle(ext::shared_ptr< SwaptionVolatilityStructure > const &)\n"
    "    RelinkableHandle< SwaptionVolatilityStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableSwaptionVolatilityStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< SwaptionVolatilityStructure > *arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *) 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwaptionVolatilityStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableSwaptionVolatilityStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableSwaptionVolatilityStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< SwaptionVolatilityStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableSwaptionVolatilityStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< SwaptionVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableSwaptionVolatilityStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< SwaptionVolatilityStructure > *arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableSwaptionVolatilityStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_SwaptionVolatilityStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableSwaptionVolatilityStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< SwaptionVolatilityStructure > *arg1 = (RelinkableHandle< SwaptionVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableSwaptionVolatilityStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< SwaptionVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< SwaptionVolatilityStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableSwaptionVolatilityStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_SwaptionVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableSwaptionVolatilityStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackConstantVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Volatility arg3 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  BlackConstantVol *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackConstantVol" "', argument " "3"" of type '" "Volatility""'");
  } 
  arg3 = static_cast< Volatility >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol((Date const &)*arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackConstantVol > *smartresult = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackConstantVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  BlackConstantVol *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackConstantVol" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol((Date const &)*arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackConstantVol > *smartresult = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackConstantVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Volatility arg3 ;
  DayCounter *arg4 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  BlackConstantVol *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BlackConstantVol" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackConstantVol" "', argument " "3"" of type '" "Volatility""'");
  } 
  arg3 = static_cast< Volatility >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackConstantVol > *smartresult = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackConstantVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  BlackConstantVol *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BlackConstantVol" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackConstantVol" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (BlackConstantVol *)new BlackConstantVol(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackConstantVol > *smartresult = result ? new ext::shared_ptr<  BlackConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackConstantVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackConstantVol", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BlackConstantVol__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BlackConstantVol__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BlackConstantVol__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BlackConstantVol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackConstantVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackConstantVol::BlackConstantVol(Date const &,Calendar const &,Volatility,DayCounter const &)\n"
    "    BlackConstantVol::BlackConstantVol(Date const &,Calendar const &,Handle< Quote > const &,DayCounter const &)\n"
    "    BlackConstantVol::BlackConstantVol(Natural,Calendar const &,Volatility,DayCounter const &)\n"
    "    BlackConstantVol::BlackConstantVol(Natural,Calendar const &,Handle< Quote > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackConstantVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackConstantVol *arg1 = (BlackConstantVol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackConstantVol > tempshared1 ;
  ext::shared_ptr< BlackConstantVol > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackConstantVol" "', argument " "1"" of type '" "BlackConstantVol *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackConstantVol > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackConstantVol > * >(argp1);
      arg1 = const_cast< BlackConstantVol * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackConstantVol > * >(argp1);
      arg1 = const_cast< BlackConstantVol * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackConstantVol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackConstantVol_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackConstantVol_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackVarianceCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  BlackVarianceCurve *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackVarianceCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackVarianceCurve" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackVarianceCurve" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackVarianceCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BlackVarianceCurve" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (BlackVarianceCurve *)new BlackVarianceCurve((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackVarianceCurve > *smartresult = result ? new ext::shared_ptr<  BlackVarianceCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackVarianceCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackVarianceCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  BlackVarianceCurve *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackVarianceCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackVarianceCurve" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackVarianceCurve" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackVarianceCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (BlackVarianceCurve *)new BlackVarianceCurve((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackVarianceCurve > *smartresult = result ? new ext::shared_ptr<  BlackVarianceCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackVarianceCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackVarianceCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackVarianceCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BlackVarianceCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_BlackVarianceCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackVarianceCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVarianceCurve::BlackVarianceCurve(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,bool)\n"
    "    BlackVarianceCurve::BlackVarianceCurve(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackVarianceCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackVarianceCurve *arg1 = (BlackVarianceCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVarianceCurve > tempshared1 ;
  ext::shared_ptr< BlackVarianceCurve > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVarianceCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackVarianceCurve" "', argument " "1"" of type '" "BlackVarianceCurve *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackVarianceCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackVarianceCurve > * >(argp1);
      arg1 = const_cast< BlackVarianceCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackVarianceCurve > * >(argp1);
      arg1 = const_cast< BlackVarianceCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackVarianceCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackVarianceCurve_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackVarianceCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackVarianceSurface(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BlackVarianceSurface::Extrapolation arg7 = (BlackVarianceSurface::Extrapolation) BlackVarianceSurface::InterpolatorDefaultExtrapolation ;
  BlackVarianceSurface::Extrapolation arg8 = (BlackVarianceSurface::Extrapolation) BlackVarianceSurface::InterpolatorDefaultExtrapolation ;
  std::string const &arg9_defvalue = "" ;
  std::string *arg9 = (std::string *) &arg9_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Matrix temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"referenceDate",  (char *)"cal",  (char *)"dates",  (char *)"strikes",  (char *)"blackVols",  (char *)"dayCounter",  (char *)"lower",  (char *)"upper",  (char *)"interpolator",  NULL 
  };
  BlackVarianceSurface *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOO:new_BlackVarianceSurface", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackVarianceSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackVarianceSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackVarianceSurface" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackVarianceSurface" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if (PyTuple_Check(obj4) || PyList_Check(obj4)) {
      Size rows, cols;
      rows = (PyTuple_Check(obj4) ?
      PyTuple_Size(obj4) :
        PyList_Size(obj4));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(obj4,0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp5 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(obj4,i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp5[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp5[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_BlackVarianceSurface" "', argument " "5"" of type '" "Matrix const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "5"" of type '" "Matrix const &""'"); 
      }
      arg5 = reinterpret_cast< Matrix * >(argp5);
    }
  }
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_BlackVarianceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_BlackVarianceSurface" "', argument " "7"" of type '" "BlackVarianceSurface::Extrapolation""'");
    } 
    arg7 = static_cast< BlackVarianceSurface::Extrapolation >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_BlackVarianceSurface" "', argument " "8"" of type '" "BlackVarianceSurface::Extrapolation""'");
    } 
    arg8 = static_cast< BlackVarianceSurface::Extrapolation >(val8);
  }
  if (obj8) {
    {
      std::string *ptr = (std::string *)0;
      res9 = SWIG_AsPtr_std_string(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_BlackVarianceSurface" "', argument " "9"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackVarianceSurface" "', argument " "9"" of type '" "std::string const &""'"); 
      }
      arg9 = ptr;
    }
  }
  {
    try {
      result = (BlackVarianceSurface *)new_BlackVarianceSurface((Date const &)*arg1,(Calendar const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(std::string const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackVarianceSurface > *smartresult = result ? new ext::shared_ptr<  BlackVarianceSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVarianceSurface_setInterpolation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVarianceSurface > tempshared1 ;
  ext::shared_ptr< BlackVarianceSurface > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVarianceSurface_setInterpolation" "', argument " "1"" of type '" "BlackVarianceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      arg1 = const_cast< BlackVarianceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      arg1 = const_cast< BlackVarianceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackVarianceSurface_setInterpolation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackVarianceSurface_setInterpolation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      BlackVarianceSurface_setInterpolation__SWIG_0(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVarianceSurface_setInterpolation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVarianceSurface > tempshared1 ;
  ext::shared_ptr< BlackVarianceSurface > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackVarianceSurface_setInterpolation" "', argument " "1"" of type '" "BlackVarianceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      arg1 = const_cast< BlackVarianceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      arg1 = const_cast< BlackVarianceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      BlackVarianceSurface_setInterpolation__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackVarianceSurface_setInterpolation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackVarianceSurface_setInterpolation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BlackVarianceSurface_setInterpolation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BlackVarianceSurface_setInterpolation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackVarianceSurface_setInterpolation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackVarianceSurface::setInterpolation(std::string const &)\n"
    "    BlackVarianceSurface::setInterpolation()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackVarianceSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackVarianceSurface *arg1 = (BlackVarianceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackVarianceSurface > tempshared1 ;
  ext::shared_ptr< BlackVarianceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackVarianceSurface" "', argument " "1"" of type '" "BlackVarianceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      arg1 = const_cast< BlackVarianceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackVarianceSurface > * >(argp1);
      arg1 = const_cast< BlackVarianceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackVarianceSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackVarianceSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackVarianceSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantOptionletVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantOptionletVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantOptionletVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantOptionletVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantOptionletVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantOptionletVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantOptionletVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantOptionletVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantOptionletVolatility *)new ConstantOptionletVolatility(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantOptionletVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstantOptionletVolatility", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantOptionletVolatility__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantOptionletVolatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantOptionletVolatility__SWIG_11(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantOptionletVolatility__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantOptionletVolatility__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantOptionletVolatility__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantOptionletVolatility__SWIG_10(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantOptionletVolatility__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantOptionletVolatility__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantOptionletVolatility__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantOptionletVolatility__SWIG_9(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantOptionletVolatility__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstantOptionletVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Date const &,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Date const &,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Date const &,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Date const &,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Date const &,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Date const &,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Natural,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Natural,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Natural,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Natural,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Natural,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const)\n"
    "    ConstantOptionletVolatility::ConstantOptionletVolatility(Natural,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConstantOptionletVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantOptionletVolatility *arg1 = (ConstantOptionletVolatility *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConstantOptionletVolatility > tempshared1 ;
  ext::shared_ptr< ConstantOptionletVolatility > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantOptionletVolatility" "', argument " "1"" of type '" "ConstantOptionletVolatility *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConstantOptionletVolatility > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConstantOptionletVolatility > * >(argp1);
      arg1 = const_cast< ConstantOptionletVolatility * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConstantOptionletVolatility > * >(argp1);
      arg1 = const_cast< ConstantOptionletVolatility * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstantOptionletVolatility_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConstantOptionletVolatility_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstantOptionletVolatility_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantSwaptionVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantSwaptionVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantSwaptionVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility(arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantSwaptionVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  VolatilityType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantSwaptionVolatility" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  Volatility arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ConstantSwaptionVolatility *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantSwaptionVolatility" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantSwaptionVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantSwaptionVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (ConstantSwaptionVolatility *)new ConstantSwaptionVolatility((Date const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantSwaptionVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantSwaptionVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantSwaptionVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstantSwaptionVolatility", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantSwaptionVolatility__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantSwaptionVolatility__SWIG_11(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantSwaptionVolatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ConstantSwaptionVolatility__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantSwaptionVolatility__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantSwaptionVolatility__SWIG_10(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantSwaptionVolatility__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ConstantSwaptionVolatility__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantSwaptionVolatility__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantSwaptionVolatility__SWIG_9(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantSwaptionVolatility__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ConstantSwaptionVolatility__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstantSwaptionVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Natural,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Natural,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Natural,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Date const &,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Date const &,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &,VolatilityType const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Date const &,Calendar const &,BusinessDayConvention,Handle< Quote > const &,DayCounter const &)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Natural,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Natural,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Natural,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Date const &,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const,Real const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Date const &,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &,VolatilityType const)\n"
    "    ConstantSwaptionVolatility::ConstantSwaptionVolatility(Date const &,Calendar const &,BusinessDayConvention,Volatility,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConstantSwaptionVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantSwaptionVolatility *arg1 = (ConstantSwaptionVolatility *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConstantSwaptionVolatility > tempshared1 ;
  ext::shared_ptr< ConstantSwaptionVolatility > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantSwaptionVolatility" "', argument " "1"" of type '" "ConstantSwaptionVolatility *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConstantSwaptionVolatility > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConstantSwaptionVolatility > * >(argp1);
      arg1 = const_cast< ConstantSwaptionVolatility * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConstantSwaptionVolatility > * >(argp1);
      arg1 = const_cast< ConstantSwaptionVolatility * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstantSwaptionVolatility_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConstantSwaptionVolatility_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstantSwaptionVolatility_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SwaptionVolatilityDiscrete_optionTenors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityDiscrete_optionTenors" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Period,std::allocator< Period > > *) &((SwaptionVolatilityDiscrete const *)arg1)->optionTenors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Period,std::allocator< Period > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityDiscrete_optionDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityDiscrete_optionDates" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((SwaptionVolatilityDiscrete const *)arg1)->optionDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityDiscrete_optionTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityDiscrete_optionTimes" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((SwaptionVolatilityDiscrete const *)arg1)->optionTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityDiscrete_swapTenors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityDiscrete_swapTenors" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Period,std::allocator< Period > > *) &((SwaptionVolatilityDiscrete const *)arg1)->swapTenors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Period,std::allocator< Period > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityDiscrete_swapLengths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityDiscrete_swapLengths" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((SwaptionVolatilityDiscrete const *)arg1)->swapLengths();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityDiscrete_optionDateFromTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwaptionVolatilityDiscrete_optionDateFromTime", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityDiscrete_optionDateFromTime" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityDiscrete_optionDateFromTime" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = ((SwaptionVolatilityDiscrete const *)arg1)->optionDateFromTime(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolatilityDiscrete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityDiscrete *arg1 = (SwaptionVolatilityDiscrete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityDiscrete > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolatilityDiscrete" "', argument " "1"" of type '" "SwaptionVolatilityDiscrete *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityDiscrete > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityDiscrete > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityDiscrete * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwaptionVolatilityDiscrete_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date,std::allocator< Date > > *arg4 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  VolatilityType arg9 ;
  Matrix *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Matrix temp10 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  {
    if (PyTuple_Check(swig_obj[9]) || PyList_Check(swig_obj[9])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[9]) ?
      PyTuple_Size(swig_obj[9]) :
        PyList_Size(swig_obj[9]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[9],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp10 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[9],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp10[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp10[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg10 = &temp10;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "10"" of type '" "Matrix const &""'");
      }
      if (!argp10) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "10"" of type '" "Matrix const &""'"); 
      }
      arg10 = reinterpret_cast< Matrix * >(argp10);
    }
  }
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date,std::allocator< Date > > const &)*arg4,(std::vector< Period,std::allocator< Period > > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7,arg8,arg9,(Matrix const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date,std::allocator< Date > > *arg4 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  VolatilityType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date,std::allocator< Date > > const &)*arg4,(std::vector< Period,std::allocator< Period > > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date,std::allocator< Date > > *arg4 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date,std::allocator< Date > > const &)*arg4,(std::vector< Period,std::allocator< Period > > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Date,std::allocator< Date > > *arg4 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Date,std::allocator< Date > > const &)*arg4,(std::vector< Period,std::allocator< Period > > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "9"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "9"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  Matrix *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Matrix temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Matrix temp9 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[4]) || PyList_Check(swig_obj[4])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[4]) ?
      PyTuple_Size(swig_obj[4]) :
        PyList_Size(swig_obj[4]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[4],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp5 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[4],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp5[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp5[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'"); 
      }
      arg5 = reinterpret_cast< Matrix * >(argp5);
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    if (PyTuple_Check(swig_obj[8]) || PyList_Check(swig_obj[8])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[8]) ?
      PyTuple_Size(swig_obj[8]) :
        PyList_Size(swig_obj[8]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[8],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp9 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[8],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp9[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp9[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg9 = &temp9;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "9"" of type '" "Matrix const &""'");
      }
      if (!argp9) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "9"" of type '" "Matrix const &""'"); 
      }
      arg9 = reinterpret_cast< Matrix * >(argp9);
    }
  }
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Matrix const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Matrix temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[4]) || PyList_Check(swig_obj[4])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[4]) ?
      PyTuple_Size(swig_obj[4]) :
        PyList_Size(swig_obj[4]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[4],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp5 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[4],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp5[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp5[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'"); 
      }
      arg5 = reinterpret_cast< Matrix * >(argp5);
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Matrix temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[4]) || PyList_Check(swig_obj[4])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[4]) ?
      PyTuple_Size(swig_obj[4]) :
        PyList_Size(swig_obj[4]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[4],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp5 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[4],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp5[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp5[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'"); 
      }
      arg5 = reinterpret_cast< Matrix * >(argp5);
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Calendar *arg1 = 0 ;
  BusinessDayConvention arg2 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  Matrix *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Matrix temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Calendar const &""'"); 
  }
  arg1 = reinterpret_cast< Calendar * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[4]) || PyList_Check(swig_obj[4])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[4]) ?
      PyTuple_Size(swig_obj[4]) :
        PyList_Size(swig_obj[4]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[4],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp5 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[4],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp5[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp5[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "Matrix const &""'"); 
      }
      arg5 = reinterpret_cast< Matrix * >(argp5);
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new SwaptionVolatilityMatrix((Calendar const &)*arg1,arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(Matrix const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  VolatilityType arg7 ;
  Matrix *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Matrix temp8 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    if (PyTuple_Check(swig_obj[7]) || PyList_Check(swig_obj[7])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[7]) ?
      PyTuple_Size(swig_obj[7]) :
        PyList_Size(swig_obj[7]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[7],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp8 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[7],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp8[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp8[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg8 = &temp8;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "Matrix const &""'");
      }
      if (!argp8) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "8"" of type '" "Matrix const &""'"); 
      }
      arg8 = reinterpret_cast< Matrix * >(argp8);
    }
  }
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Matrix const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  VolatilityType arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwaptionVolatilityMatrix *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionVolatilityMatrix" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (SwaptionVolatilityMatrix *)new_SwaptionVolatilityMatrix__SWIG_12((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(Matrix const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionVolatilityMatrix > *smartresult = result ? new ext::shared_ptr<  SwaptionVolatilityMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionVolatilityMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwaptionVolatilityMatrix", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SwaptionVolatilityMatrix__SWIG_15(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SwaptionVolatilityMatrix__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SwaptionVolatilityMatrix__SWIG_14(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              /* native sequence? */
              if (PyTuple_Check(argv[4]) || PyList_Check(argv[4])) {
                _v = 1;
                /* wrapped Matrix? */
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SwaptionVolatilityMatrix__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SwaptionVolatilityMatrix__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Date,std::allocator< Date > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Period,std::allocator< Period > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SwaptionVolatilityMatrix__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SwaptionVolatilityMatrix__SWIG_13(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              /* native sequence? */
              if (PyTuple_Check(argv[4]) || PyList_Check(argv[4])) {
                _v = 1;
                /* wrapped Matrix? */
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SwaptionVolatilityMatrix__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Date,std::allocator< Date > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Period,std::allocator< Period > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SwaptionVolatilityMatrix__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SwaptionVolatilityMatrix__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    /* native sequence? */
                    if (PyTuple_Check(argv[7]) || PyList_Check(argv[7])) {
                      _v = 1;
                      /* wrapped Matrix? */
                    } else {
                      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                  }
                  if (_v) {
                    return _wrap_new_SwaptionVolatilityMatrix__SWIG_12(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              /* native sequence? */
              if (PyTuple_Check(argv[4]) || PyList_Check(argv[4])) {
                _v = 1;
                /* wrapped Matrix? */
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SwaptionVolatilityMatrix__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Date,std::allocator< Date > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Period,std::allocator< Period > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SwaptionVolatilityMatrix__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_SwaptionVolatilityMatrix__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              /* native sequence? */
              if (PyTuple_Check(argv[4]) || PyList_Check(argv[4])) {
                _v = 1;
                /* wrapped Matrix? */
              } else {
                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      /* native sequence? */
                      if (PyTuple_Check(argv[8]) || PyList_Check(argv[8])) {
                        _v = 1;
                        /* wrapped Matrix? */
                      } else {
                        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                        _v = SWIG_CheckState(res);
                      }
                    }
                    if (_v) {
                      return _wrap_new_SwaptionVolatilityMatrix__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Date,std::allocator< Date > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Period,std::allocator< Period > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        /* native sequence? */
                        if (PyTuple_Check(argv[9]) || PyList_Check(argv[9])) {
                          _v = 1;
                          /* wrapped Matrix? */
                        } else {
                          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                          _v = SWIG_CheckState(res);
                        }
                      }
                      if (_v) {
                        return _wrap_new_SwaptionVolatilityMatrix__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwaptionVolatilityMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,Calendar const &,BusinessDayConvention,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const,VolatilityType const,Matrix const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,Calendar const &,BusinessDayConvention,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const,VolatilityType const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,Calendar const &,BusinessDayConvention,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,Calendar const &,BusinessDayConvention,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,DayCounter const &,bool const,VolatilityType const,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,DayCounter const &,bool const,VolatilityType const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,DayCounter const &,bool const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,DayCounter const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const,VolatilityType const,Matrix const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const,VolatilityType const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const,VolatilityType const,Matrix const &)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const,VolatilityType const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &,bool const)\n"
    "    SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityMatrix_locate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::pair< unsigned int,unsigned int > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "1"" of type '" "SwaptionVolatilityMatrix const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = SwaptionVolatilityMatrix_locate__SWIG_0((SwaptionVolatilityMatrix const *)arg1,(Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityMatrix_locate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  std::pair< unsigned int,unsigned int > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "1"" of type '" "SwaptionVolatilityMatrix const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SwaptionVolatilityMatrix_locate" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = SwaptionVolatilityMatrix_locate__SWIG_1((SwaptionVolatilityMatrix const *)arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityMatrix_locate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwaptionVolatilityMatrix_locate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SwaptionVolatilityMatrix_locate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SwaptionVolatilityMatrix_locate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwaptionVolatilityMatrix_locate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionVolatilityMatrix::locate(Date const &,Period const &) const\n"
    "    SwaptionVolatilityMatrix::locate(Time,Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionVolatilityMatrix_volatilityType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityMatrix const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  VolatilityType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityMatrix_volatilityType" "', argument " "1"" of type '" "SwaptionVolatilityMatrix const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (VolatilityType)((SwaptionVolatilityMatrix const *)arg1)->volatilityType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolatilityMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityMatrix *arg1 = (SwaptionVolatilityMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityMatrix > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityMatrix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolatilityMatrix" "', argument " "1"" of type '" "SwaptionVolatilityMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityMatrix > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwaptionVolatilityMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityMatrix_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwaptionVolatilityMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Real arg6 ;
  VolatilityType arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SabrSmileSection" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SabrSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Date const &)*arg4,(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SabrSmileSection" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Date const &)*arg4,(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Date const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SabrSmileSection" "', argument " "5"" of type '" "VolatilityType""'");
  } 
  arg5 = static_cast< VolatilityType >(val5);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SabrSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  SabrSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SabrSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (SabrSmileSection *)new SabrSmileSection(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SabrSmileSection", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SabrSmileSection__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SabrSmileSection__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SabrSmileSection__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SabrSmileSection__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SabrSmileSection__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SabrSmileSection__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SabrSmileSection__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SabrSmileSection__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SabrSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SabrSmileSection::SabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,Date const &,DayCounter const &,Real,VolatilityType)\n"
    "    SabrSmileSection::SabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,Date const &,DayCounter const &,Real)\n"
    "    SabrSmileSection::SabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,Date const &,DayCounter const &)\n"
    "    SabrSmileSection::SabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,Date const &)\n"
    "    SabrSmileSection::SabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &)\n"
    "    SabrSmileSection::SabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,Real,VolatilityType)\n"
    "    SabrSmileSection::SabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    SabrSmileSection::SabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SabrSmileSection_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSmileSection const > tempshared1 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSmileSection_alpha" "', argument " "1"" of type '" "SabrSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SabrSmileSection const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSmileSection_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSmileSection const > tempshared1 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSmileSection_beta" "', argument " "1"" of type '" "SabrSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SabrSmileSection const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSmileSection_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSmileSection const > tempshared1 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSmileSection_nu" "', argument " "1"" of type '" "SabrSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SabrSmileSection const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSmileSection const > tempshared1 ;
  ext::shared_ptr< SabrSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSmileSection_rho" "', argument " "1"" of type '" "SabrSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SabrSmileSection const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SabrSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSmileSection *arg1 = (SabrSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSmileSection > tempshared1 ;
  ext::shared_ptr< SabrSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SabrSmileSection" "', argument " "1"" of type '" "SabrSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SabrSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SabrSmileSection > * >(argp1);
      arg1 = const_cast< SabrSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SabrSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SabrSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SviSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SviSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SviSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SviSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (SviSmileSection *)new SviSmileSection(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviSmileSection > *smartresult = result ? new ext::shared_ptr<  SviSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > arg3 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SviSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SviSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SviSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (SviSmileSection *)new SviSmileSection((Date const &)*arg1,arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviSmileSection > *smartresult = result ? new ext::shared_ptr<  SviSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SviSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SviSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (SviSmileSection *)new SviSmileSection((Date const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviSmileSection > *smartresult = result ? new ext::shared_ptr<  SviSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SviSmileSection", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SviSmileSection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SviSmileSection__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SviSmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SviSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SviSmileSection::SviSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > >)\n"
    "    SviSmileSection::SviSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > >,DayCounter const &)\n"
    "    SviSmileSection::SviSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SviSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviSmileSection *arg1 = (SviSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviSmileSection > tempshared1 ;
  ext::shared_ptr< SviSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SviSmileSection" "', argument " "1"" of type '" "SviSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SviSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SviSmileSection > * >(argp1);
      arg1 = const_cast< SviSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SviSmileSection > * >(argp1);
      arg1 = const_cast< SviSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SviSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SviSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SviSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  void *argp19 ;
  int res19 = 0 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_SviInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria >""'");
    }
    if (argp18) arg18 = *(reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_SviInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod >""'");
    }
    if (argp19) arg19 = *(reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_SviInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  void *argp19 ;
  int res19 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_SviInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria >""'");
    }
    if (argp18) arg18 = *(reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_SviInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod >""'");
    }
    if (argp19) arg19 = *(reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
  }
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_SviInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria >""'");
    }
    if (argp18) arg18 = *(reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
  }
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > arg2 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > arg5 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  void *argp19 ;
  int res19 = 0 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_SviInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria >""'");
    }
    if (argp18) arg18 = *(reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_SviInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod >""'");
    }
    if (argp19) arg19 = *(reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_SviInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  ext::shared_ptr< OptimizationMethod > arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  void *argp19 ;
  int res19 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_SviInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria >""'");
    }
    if (argp18) arg18 = *(reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_SviInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod >""'");
    }
    if (argp19) arg19 = *(reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
  }
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_SviInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria >""'");
    }
    if (argp18) arg18 = *(reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
  }
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SviInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  SviInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SviInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SviInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SviInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SviInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SviInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SviInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SviInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SviInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SviInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SviInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SviInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SviInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SviInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SviInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (SviInterpolatedSmileSection *)new SviInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SviInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  SviInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SviInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SviInterpolatedSmileSection", 0, 20, argv))) SWIG_fail;
  --argc;
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SviInterpolatedSmileSection__SWIG_4(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SviInterpolatedSmileSection__SWIG_9(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_SviInterpolatedSmileSection__SWIG_3(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_SviInterpolatedSmileSection__SWIG_8(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_SviInterpolatedSmileSection__SWIG_2(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_SviInterpolatedSmileSection__SWIG_7(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_SviInterpolatedSmileSection__SWIG_1(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_SviInterpolatedSmileSection__SWIG_6(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_SviInterpolatedSmileSection__SWIG_0(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_SviInterpolatedSmileSection__SWIG_5(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SviInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Handle< Quote >,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote >,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria >,ext::shared_ptr< OptimizationMethod >,DayCounter const &)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Handle< Quote >,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote >,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria >,ext::shared_ptr< OptimizationMethod >)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Handle< Quote >,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote >,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria >)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Handle< Quote >,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote >,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Handle< Quote >,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote >,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria >,ext::shared_ptr< OptimizationMethod >,DayCounter const &)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria >,ext::shared_ptr< OptimizationMethod >)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria >)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    SviInterpolatedSmileSection::SviInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_a(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_a" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->a();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_b" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->b();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_sigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_sigma" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->sigma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_rho" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_m(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_m" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->m();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_rmsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_rmsError" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_maxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_maxError" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((SviInterpolatedSmileSection const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SviInterpolatedSmileSection_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SviInterpolatedSmileSection_endCriteria" "', argument " "1"" of type '" "SviInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((SviInterpolatedSmileSection const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SviInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SviInterpolatedSmileSection *arg1 = (SviInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SviInterpolatedSmileSection > tempshared1 ;
  ext::shared_ptr< SviInterpolatedSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SviInterpolatedSmileSection" "', argument " "1"" of type '" "SviInterpolatedSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SviInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SviInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< SviInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SviInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SviInterpolatedSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SviInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SwaptionVolatilityCube_atmStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityCube *arg1 = (SwaptionVolatilityCube *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityCube const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwaptionVolatilityCube_atmStrike", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionVolatilityCube_atmStrike" "', argument " "1"" of type '" "SwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwaptionVolatilityCube_atmStrike" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityCube_atmStrike" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SwaptionVolatilityCube_atmStrike" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwaptionVolatilityCube_atmStrike" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)((SwaptionVolatilityCube const *)arg1)->atmStrike((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionVolatilityCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionVolatilityCube *arg1 = (SwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionVolatilityCube > tempshared1 ;
  ext::shared_ptr< SwaptionVolatilityCube > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionVolatilityCube" "', argument " "1"" of type '" "SwaptionVolatilityCube *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwaptionVolatilityCube_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityCube_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  Size arg17 ;
  bool arg18 ;
  Real arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared14 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  size_t val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  double val19 ;
  int ecode19 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &argp14, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "14"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      arg14 = &tempshared14;
    } else {
      arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14) : &tempshared14;
    }
  }
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_size_t(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "17"" of type '" "Size""'");
  } 
  arg17 = static_cast< Size >(val17);
  ecode18 = SWIG_AsVal_bool(swig_obj[17], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_double(swig_obj[18], &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "19"" of type '" "Real""'");
  } 
  arg19 = static_cast< Real >(val19);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15,arg16,arg17,arg18,arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  Size arg17 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared14 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  size_t val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &argp14, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "14"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      arg14 = &tempshared14;
    } else {
      arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14) : &tempshared14;
    }
  }
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_size_t(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "17"" of type '" "Size""'");
  } 
  arg17 = static_cast< Size >(val17);
  ecode18 = SWIG_AsVal_bool(swig_obj[17], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15,arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  Size arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared14 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  size_t val17 ;
  int ecode17 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &argp14, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "14"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      arg14 = &tempshared14;
    } else {
      arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14) : &tempshared14;
    }
  }
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_size_t(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "17"" of type '" "Size""'");
  } 
  arg17 = static_cast< Size >(val17);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared14 ;
  double val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &argp14, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "14"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      arg14 = &tempshared14;
    } else {
      arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14) : &tempshared14;
    }
  }
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  Real arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared14 ;
  double val15 ;
  int ecode15 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &argp14, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "14"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      arg14 = &tempshared14;
    } else {
      arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14) : &tempshared14;
    }
  }
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  ext::shared_ptr< OptimizationMethod > *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared14 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    int newmem = 0;
    res14 = SWIG_ConvertPtrAndOwn(swig_obj[13], &argp14, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "14"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp14) tempshared14 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14);
      arg14 = &tempshared14;
    } else {
      arg14 = (argp14) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp14) : &tempshared14;
    }
  }
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13,(ext::shared_ptr< OptimizationMethod > const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  Real arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  double val13 ;
  int ecode13 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  ext::shared_ptr< EndCriteria > *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared12 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "12"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp12) : &tempshared12;
    }
  }
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11,(ext::shared_ptr< EndCriteria > const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg9 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg10 = 0 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  SabrSwaptionVolatilityCube *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "9"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "10"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg10 = ptr;
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SabrSwaptionVolatilityCube" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (SabrSwaptionVolatilityCube *)new SabrSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg9,(std::vector< bool,std::allocator< bool > > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  SabrSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SabrSwaptionVolatilityCube(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[20] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SabrSwaptionVolatilityCube", 0, 19, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SabrSwaptionVolatilityCube__SWIG_8(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_SabrSwaptionVolatilityCube__SWIG_7(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_SabrSwaptionVolatilityCube__SWIG_6(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_SabrSwaptionVolatilityCube__SWIG_5(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_SabrSwaptionVolatilityCube__SWIG_4(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SabrSwaptionVolatilityCube__SWIG_3(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_size_t(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_SabrSwaptionVolatilityCube__SWIG_2(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_size_t(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_new_SabrSwaptionVolatilityCube__SWIG_1(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Period,std::allocator< Period > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Period,std::allocator< Period > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector<bool,std::allocator< bool > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_size_t(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_double(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_new_SabrSwaptionVolatilityCube__SWIG_0(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SabrSwaptionVolatilityCube'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const,Size const,bool const,Real const)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const,Size const,bool const)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const,Size const)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real,ext::shared_ptr< OptimizationMethod > const &,Real const,bool const)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real,ext::shared_ptr< OptimizationMethod > const &,Real const)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &,Real)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    SabrSwaptionVolatilityCube::SabrSwaptionVolatilityCube(Handle< SwaptionVolatilityStructure > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Period,std::allocator< Period > > const &,std::vector< Spread,std::allocator< Spread > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,ext::shared_ptr< SwapIndex > const &,ext::shared_ptr< SwapIndex > const &,bool,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,std::vector< bool,std::allocator< bool > > const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_sparseSabrParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_sparseSabrParameters" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->sparseSabrParameters();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_denseSabrParameters(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_denseSabrParameters" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->denseSabrParameters();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_marketVolCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_marketVolCube" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->marketVolCube();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_volCubeAtmCalibrated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_volCubeAtmCalibrated" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SabrSwaptionVolatilityCube const *)arg1)->volCubeAtmCalibrated();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_0((SabrSwaptionVolatilityCube const *)arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_0((SabrSwaptionVolatilityCube const *)arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_2((SabrSwaptionVolatilityCube const *)arg1,(Period const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< SabrSmileSection > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SabrSwaptionVolatilityCube_smileSection" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = SabrSwaptionVolatilityCube_smileSection__SWIG_2((SabrSwaptionVolatilityCube const *)arg1,(Period const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SabrSmileSection > *smartresult = result ? new ext::shared_ptr<  SabrSmileSection >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SabrSmileSection_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SabrSwaptionVolatilityCube_smileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SabrSwaptionVolatilityCube_smileSection", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SabrSwaptionVolatilityCube_smileSection__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SabrSwaptionVolatilityCube_smileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SabrSwaptionVolatilityCube::smileSection(Time,Time,bool) const\n"
    "    SabrSwaptionVolatilityCube::smileSection(Time,Time) const\n"
    "    SabrSwaptionVolatilityCube::smileSection(Period const &,Period const &,bool) const\n"
    "    SabrSwaptionVolatilityCube::smileSection(Period const &,Period const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SabrSwaptionVolatilityCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SabrSwaptionVolatilityCube *arg1 = (SabrSwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube > tempshared1 ;
  ext::shared_ptr< SabrSwaptionVolatilityCube > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SabrSwaptionVolatilityCube" "', argument " "1"" of type '" "SabrSwaptionVolatilityCube *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SabrSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SabrSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< SabrSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SabrSwaptionVolatilityCube_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SabrSwaptionVolatilityCube_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InterpolatedSwaptionVolatilityCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg2 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg3 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg4 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg5 = 0 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  ext::shared_ptr< SwapIndex > *arg7 = 0 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared7 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  InterpolatedSwaptionVolatilityCube *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_InterpolatedSwaptionVolatilityCube", 8, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "2"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "3"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "4"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "5"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "7"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_InterpolatedSwaptionVolatilityCube" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (InterpolatedSwaptionVolatilityCube *)new InterpolatedSwaptionVolatilityCube((Handle< SwaptionVolatilityStructure > const &)*arg1,(std::vector< Period,std::allocator< Period > > const &)*arg2,(std::vector< Period,std::allocator< Period > > const &)*arg3,(std::vector< Spread,std::allocator< Spread > > const &)*arg4,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,(ext::shared_ptr< SwapIndex > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSwaptionVolatilityCube > *smartresult = result ? new ext::shared_ptr<  InterpolatedSwaptionVolatilityCube >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InterpolatedSwaptionVolatilityCube(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSwaptionVolatilityCube *arg1 = (InterpolatedSwaptionVolatilityCube *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSwaptionVolatilityCube > tempshared1 ;
  ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterpolatedSwaptionVolatilityCube" "', argument " "1"" of type '" "InterpolatedSwaptionVolatilityCube *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedSwaptionVolatilityCube > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< InterpolatedSwaptionVolatilityCube * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedSwaptionVolatilityCube > * >(argp1);
      arg1 = const_cast< InterpolatedSwaptionVolatilityCube * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InterpolatedSwaptionVolatilityCube_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InterpolatedSwaptionVolatilityCube_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConstantYoYOptionletVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Volatility arg1 ;
  Natural arg2 ;
  Calendar *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  DayCounter *arg5 = 0 ;
  Period *arg6 = 0 ;
  Frequency arg7 ;
  bool arg8 ;
  Real arg9 ;
  Real arg10 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  ConstantYoYOptionletVolatility *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "1"" of type '" "Volatility""'");
  } 
  arg1 = static_cast< Volatility >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "4"" of type '" "BusinessDayConvention""'");
  } 
  arg4 = static_cast< BusinessDayConvention >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (ConstantYoYOptionletVolatility *)new ConstantYoYOptionletVolatility(arg1,arg2,(Calendar const &)*arg3,arg4,(DayCounter const &)*arg5,(Period const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantYoYOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantYoYOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantYoYOptionletVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Volatility arg1 ;
  Natural arg2 ;
  Calendar *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  DayCounter *arg5 = 0 ;
  Period *arg6 = 0 ;
  Frequency arg7 ;
  bool arg8 ;
  Real arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  ConstantYoYOptionletVolatility *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "1"" of type '" "Volatility""'");
  } 
  arg1 = static_cast< Volatility >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "4"" of type '" "BusinessDayConvention""'");
  } 
  arg4 = static_cast< BusinessDayConvention >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (ConstantYoYOptionletVolatility *)new ConstantYoYOptionletVolatility(arg1,arg2,(Calendar const &)*arg3,arg4,(DayCounter const &)*arg5,(Period const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantYoYOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantYoYOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantYoYOptionletVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Volatility arg1 ;
  Natural arg2 ;
  Calendar *arg3 = 0 ;
  BusinessDayConvention arg4 ;
  DayCounter *arg5 = 0 ;
  Period *arg6 = 0 ;
  Frequency arg7 ;
  bool arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  ConstantYoYOptionletVolatility *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "1"" of type '" "Volatility""'");
  } 
  arg1 = static_cast< Volatility >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "4"" of type '" "BusinessDayConvention""'");
  } 
  arg4 = static_cast< BusinessDayConvention >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ConstantYoYOptionletVolatility" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (ConstantYoYOptionletVolatility *)new ConstantYoYOptionletVolatility(arg1,arg2,(Calendar const &)*arg3,arg4,(DayCounter const &)*arg5,(Period const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstantYoYOptionletVolatility > *smartresult = result ? new ext::shared_ptr<  ConstantYoYOptionletVolatility >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantYoYOptionletVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstantYoYOptionletVolatility", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ConstantYoYOptionletVolatility__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ConstantYoYOptionletVolatility__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ConstantYoYOptionletVolatility__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstantYoYOptionletVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConstantYoYOptionletVolatility::ConstantYoYOptionletVolatility(Volatility,Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,Frequency,bool,Real,Real)\n"
    "    ConstantYoYOptionletVolatility::ConstantYoYOptionletVolatility(Volatility,Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,Frequency,bool,Real)\n"
    "    ConstantYoYOptionletVolatility::ConstantYoYOptionletVolatility(Volatility,Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConstantYoYOptionletVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantYoYOptionletVolatility *arg1 = (ConstantYoYOptionletVolatility *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConstantYoYOptionletVolatility > tempshared1 ;
  ext::shared_ptr< ConstantYoYOptionletVolatility > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantYoYOptionletVolatility" "', argument " "1"" of type '" "ConstantYoYOptionletVolatility *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConstantYoYOptionletVolatility > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConstantYoYOptionletVolatility > * >(argp1);
      arg1 = const_cast< ConstantYoYOptionletVolatility * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConstantYoYOptionletVolatility > * >(argp1);
      arg1 = const_cast< ConstantYoYOptionletVolatility * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstantYoYOptionletVolatility_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstantYoYOptionletVolatility_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  VolatilityType arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatSmileSection" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FlatSmileSection" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FlatSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter const &)*arg3,(Date const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  VolatilityType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatSmileSection" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FlatSmileSection" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter const &)*arg3,(Date const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatSmileSection" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection((Date const &)*arg1,arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  Real arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatSmileSection" "', argument " "5"" of type '" "VolatilityType""'");
  } 
  arg5 = static_cast< VolatilityType >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FlatSmileSection" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlatSmileSection" "', argument " "5"" of type '" "VolatilityType""'");
  } 
  arg5 = static_cast< VolatilityType >(val5);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlatSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(arg1,arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FlatSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlatSmileSection" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatSmileSection" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (FlatSmileSection *)new FlatSmileSection(arg1,arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatSmileSection > *smartresult = result ? new ext::shared_ptr<  FlatSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FlatSmileSection", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FlatSmileSection__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FlatSmileSection__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FlatSmileSection__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FlatSmileSection__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlatSmileSection__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlatSmileSection__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FlatSmileSection__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FlatSmileSection__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FlatSmileSection__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FlatSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FlatSmileSection::FlatSmileSection(Date const &,Volatility,DayCounter const &,Date const &,Real,VolatilityType,Real)\n"
    "    FlatSmileSection::FlatSmileSection(Date const &,Volatility,DayCounter const &,Date const &,Real,VolatilityType)\n"
    "    FlatSmileSection::FlatSmileSection(Date const &,Volatility,DayCounter const &,Date const &,Real)\n"
    "    FlatSmileSection::FlatSmileSection(Date const &,Volatility,DayCounter const &,Date const &)\n"
    "    FlatSmileSection::FlatSmileSection(Date const &,Volatility,DayCounter const &)\n"
    "    FlatSmileSection::FlatSmileSection(Time,Volatility,DayCounter const &,Real,VolatilityType,Real)\n"
    "    FlatSmileSection::FlatSmileSection(Time,Volatility,DayCounter const &,Real,VolatilityType)\n"
    "    FlatSmileSection::FlatSmileSection(Time,Volatility,DayCounter const &,Real)\n"
    "    FlatSmileSection::FlatSmileSection(Time,Volatility,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FlatSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FlatSmileSection *arg1 = (FlatSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FlatSmileSection > tempshared1 ;
  ext::shared_ptr< FlatSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlatSmileSection" "', argument " "1"" of type '" "FlatSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FlatSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FlatSmileSection > * >(argp1);
      arg1 = const_cast< FlatSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FlatSmileSection > * >(argp1);
      arg1 = const_cast< FlatSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FlatSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FlatSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FlatSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Linear *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Linear const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Linear const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Linear const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Linear *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Linear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Linear *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Linear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinearInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< Linear > *)new InterpolatedSmileSection< Linear >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LinearInterpolatedSmileSection", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LinearInterpolatedSmileSection__SWIG_15(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LinearInterpolatedSmileSection__SWIG_21(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LinearInterpolatedSmileSection__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LinearInterpolatedSmileSection__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LinearInterpolatedSmileSection__SWIG_14(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LinearInterpolatedSmileSection__SWIG_20(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LinearInterpolatedSmileSection__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LinearInterpolatedSmileSection__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_LinearInterpolatedSmileSection__SWIG_13(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_LinearInterpolatedSmileSection__SWIG_19(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_LinearInterpolatedSmileSection__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_LinearInterpolatedSmileSection__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_LinearInterpolatedSmileSection__SWIG_12(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_LinearInterpolatedSmileSection__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LinearInterpolatedSmileSection__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LinearInterpolatedSmileSection__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_LinearInterpolatedSmileSection__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_LinearInterpolatedSmileSection__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_LinearInterpolatedSmileSection__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_LinearInterpolatedSmileSection__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_LinearInterpolatedSmileSection__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_LinearInterpolatedSmileSection__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LinearInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Linear const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Linear const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Linear const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Linear const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Linear const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Linear const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Linear const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Linear const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Linear const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Linear const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Linear const &,Date const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Linear const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Linear const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Linear const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Linear const &,Date const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Linear const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &)\n"
    "    InterpolatedSmileSection< Linear >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LinearInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSmileSection< Linear > *arg1 = (InterpolatedSmileSection< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSmileSection< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedSmileSection< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearInterpolatedSmileSection" "', argument " "1"" of type '" "InterpolatedSmileSection< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LinearInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LinearInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(Cubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Cubic const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Cubic const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Cubic const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  Cubic *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(Cubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(Cubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< Cubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< Cubic > *)new InterpolatedSmileSection< Cubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CubicInterpolatedSmileSection", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_CubicInterpolatedSmileSection__SWIG_15(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_CubicInterpolatedSmileSection__SWIG_21(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_CubicInterpolatedSmileSection__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_CubicInterpolatedSmileSection__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CubicInterpolatedSmileSection__SWIG_14(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CubicInterpolatedSmileSection__SWIG_20(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CubicInterpolatedSmileSection__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CubicInterpolatedSmileSection__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CubicInterpolatedSmileSection__SWIG_13(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CubicInterpolatedSmileSection__SWIG_19(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CubicInterpolatedSmileSection__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CubicInterpolatedSmileSection__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CubicInterpolatedSmileSection__SWIG_12(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CubicInterpolatedSmileSection__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CubicInterpolatedSmileSection__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CubicInterpolatedSmileSection__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CubicInterpolatedSmileSection__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CubicInterpolatedSmileSection__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CubicInterpolatedSmileSection__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CubicInterpolatedSmileSection__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CubicInterpolatedSmileSection__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CubicInterpolatedSmileSection__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CubicInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Cubic const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Cubic const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Cubic const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,Cubic const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Cubic const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Cubic const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Cubic const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,Cubic const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Cubic const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Cubic const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Cubic const &,Date const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,Cubic const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Cubic const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Cubic const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Cubic const &,Date const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,Cubic const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &)\n"
    "    InterpolatedSmileSection< Cubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CubicInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSmileSection< Cubic > *arg1 = (InterpolatedSmileSection< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSmileSection< Cubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedSmileSection< Cubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CubicInterpolatedSmileSection" "', argument " "1"" of type '" "InterpolatedSmileSection< Cubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CubicInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CubicInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(MonotonicCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(MonotonicCubic const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(MonotonicCubic const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(MonotonicCubic const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  MonotonicCubic *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(MonotonicCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  MonotonicCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "6"" of type '" "MonotonicCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicCubic * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(MonotonicCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MonotonicCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< MonotonicCubic > *)new InterpolatedSmileSection< MonotonicCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MonotonicCubicInterpolatedSmileSection", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_15(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_21(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_14(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_20(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_13(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_19(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_12(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_MonotonicCubicInterpolatedSmileSection__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MonotonicCubicInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,MonotonicCubic const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,MonotonicCubic const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,MonotonicCubic const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,MonotonicCubic const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,MonotonicCubic const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,MonotonicCubic const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,MonotonicCubic const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,MonotonicCubic const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,MonotonicCubic const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,MonotonicCubic const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,MonotonicCubic const &,Date const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,MonotonicCubic const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,MonotonicCubic const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,MonotonicCubic const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,MonotonicCubic const &,Date const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,MonotonicCubic const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &)\n"
    "    InterpolatedSmileSection< MonotonicCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicCubicInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSmileSection< MonotonicCubic > *arg1 = (InterpolatedSmileSection< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicCubicInterpolatedSmileSection" "', argument " "1"" of type '" "InterpolatedSmileSection< MonotonicCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicCubicInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicCubicInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(SplineCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(SplineCubic const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  VolatilityType arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "VolatilityType""'");
  } 
  arg7 = static_cast< VolatilityType >(val7);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(SplineCubic const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(SplineCubic const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  SplineCubic *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(SplineCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >(arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  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 val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  VolatilityType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5,(SplineCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  InterpolatedSmileSection< SplineCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SplineCubicInterpolatedSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InterpolatedSmileSection< SplineCubic > *)new InterpolatedSmileSection< SplineCubic >((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SplineCubicInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SplineCubicInterpolatedSmileSection", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_15(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_21(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_14(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_20(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_13(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_19(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_12(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SplineCubicInterpolatedSmileSection__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SplineCubicInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,SplineCubic const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,SplineCubic const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,SplineCubic const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,SplineCubic const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,SplineCubic const &,DayCounter const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,SplineCubic const &,DayCounter const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,SplineCubic const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,SplineCubic const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Time,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,SplineCubic const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,SplineCubic const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,SplineCubic const &,Date const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &,SplineCubic const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Handle< Quote > const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,SplineCubic const &,Date const &,VolatilityType const,Real const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,SplineCubic const &,Date const &,VolatilityType const)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,SplineCubic const &,Date const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &,SplineCubic const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real,DayCounter const &)\n"
    "    InterpolatedSmileSection< SplineCubic >::InterpolatedSmileSection(Date const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SplineCubicInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSmileSection< SplineCubic > *arg1 = (InterpolatedSmileSection< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SplineCubicInterpolatedSmileSection" "', argument " "1"" of type '" "InterpolatedSmileSection< SplineCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedSmileSection<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedSmileSection< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SplineCubicInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SplineCubicInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Real arg7 ;
  int arg8 ;
  int arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KahaleSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_KahaleSmileSection" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_KahaleSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_KahaleSmileSection" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_KahaleSmileSection" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Real arg7 ;
  int arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KahaleSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_KahaleSmileSection" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_KahaleSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_KahaleSmileSection" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KahaleSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_KahaleSmileSection" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_KahaleSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KahaleSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_KahaleSmileSection" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KahaleSmileSection" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KahaleSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_KahaleSmileSection" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_KahaleSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KahaleSmileSection" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KahaleSmileSection" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< SmileSection > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  KahaleSmileSection *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KahaleSmileSection" "', argument " "1"" of type '" "ext::shared_ptr< SmileSection > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SmileSection > * >(argp1);
  }
  {
    try {
      result = (KahaleSmileSection *)new KahaleSmileSection(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KahaleSmileSection > *smartresult = result ? new ext::shared_ptr<  KahaleSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KahaleSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KahaleSmileSection", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_KahaleSmileSection__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_KahaleSmileSection__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_KahaleSmileSection__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_KahaleSmileSection__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_KahaleSmileSection__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_KahaleSmileSection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_KahaleSmileSection__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_KahaleSmileSection__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_SmileSection_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_KahaleSmileSection__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KahaleSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,Real const,int const,int const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,Real const,int const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,Real const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const,bool const,bool const,std::vector< Real,std::allocator< Real > > const &)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const,bool const,bool const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const,bool const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const,bool const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const,Real const)\n"
    "    KahaleSmileSection::KahaleSmileSection(ext::shared_ptr< SmileSection > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_KahaleSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KahaleSmileSection *arg1 = (KahaleSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KahaleSmileSection > tempshared1 ;
  ext::shared_ptr< KahaleSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KahaleSmileSection" "', argument " "1"" of type '" "KahaleSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  KahaleSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  KahaleSmileSection > * >(argp1);
      arg1 = const_cast< KahaleSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  KahaleSmileSection > * >(argp1);
      arg1 = const_cast< KahaleSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KahaleSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_KahaleSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KahaleSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrShortMaturityLognormal *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZabrShortMaturityLognormal", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ZabrShortMaturityLognormal *)new ZabrShortMaturityLognormal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ZabrShortMaturityLognormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrShortMaturityLognormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrShortMaturityLognormal *arg1 = (ZabrShortMaturityLognormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ZabrShortMaturityLognormal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrShortMaturityLognormal" "', argument " "1"" of type '" "ZabrShortMaturityLognormal *""'"); 
  }
  arg1 = reinterpret_cast< ZabrShortMaturityLognormal * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrShortMaturityLognormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ZabrShortMaturityLognormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrShortMaturityLognormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrShortMaturityNormal *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZabrShortMaturityNormal", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ZabrShortMaturityNormal *)new ZabrShortMaturityNormal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ZabrShortMaturityNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrShortMaturityNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrShortMaturityNormal *arg1 = (ZabrShortMaturityNormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ZabrShortMaturityNormal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrShortMaturityNormal" "', argument " "1"" of type '" "ZabrShortMaturityNormal *""'"); 
  }
  arg1 = reinterpret_cast< ZabrShortMaturityNormal * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrShortMaturityNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ZabrShortMaturityNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrShortMaturityNormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrLocalVolatility *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZabrLocalVolatility", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ZabrLocalVolatility *)new ZabrLocalVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ZabrLocalVolatility, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrLocalVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrLocalVolatility *arg1 = (ZabrLocalVolatility *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ZabrLocalVolatility, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrLocalVolatility" "', argument " "1"" of type '" "ZabrLocalVolatility *""'"); 
  }
  arg1 = reinterpret_cast< ZabrLocalVolatility * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrLocalVolatility_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ZabrLocalVolatility, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrLocalVolatility_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrFullFd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrFullFd *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZabrFullFd", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ZabrFullFd *)new ZabrFullFd();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ZabrFullFd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrFullFd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrFullFd *arg1 = (ZabrFullFd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ZabrFullFd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrFullFd" "', argument " "1"" of type '" "ZabrFullFd *""'"); 
  }
  arg1 = reinterpret_cast< ZabrFullFd * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrFullFd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ZabrFullFd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrFullFd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Size arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  size_t val5 ;
  int ecode5 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  size_t val6 ;
  int ecode6 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityLognormal > *)new ZabrSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrShortMaturityLognormalSmileSection", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ZabrShortMaturityLognormalSmileSection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrShortMaturityLognormalSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityLognormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZabrShortMaturityLognormalSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > tempshared1 ;
  ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrShortMaturityLognormalSmileSection" "', argument " "1"" of type '" "ZabrSmileSection< ZabrShortMaturityLognormal > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrShortMaturityLognormalSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrShortMaturityLognormalSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Size arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  size_t val5 ;
  int ecode5 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  size_t val6 ;
  int ecode6 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrShortMaturityNormal > *)new ZabrSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrShortMaturityNormalSmileSection", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ZabrShortMaturityNormalSmileSection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrShortMaturityNormalSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n"
    "    ZabrSmileSection< ZabrShortMaturityNormal >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZabrShortMaturityNormalSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > tempshared1 ;
  ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrShortMaturityNormalSmileSection" "', argument " "1"" of type '" "ZabrSmileSection< ZabrShortMaturityNormal > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrShortMaturityNormalSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrShortMaturityNormalSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Size arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  size_t val5 ;
  int ecode5 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  size_t val6 ;
  int ecode6 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilitySmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrLocalVolatility > *)new ZabrSmileSection< ZabrLocalVolatility >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilitySmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrLocalVolatilitySmileSection", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ZabrLocalVolatilitySmileSection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrLocalVolatilitySmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n"
    "    ZabrSmileSection< ZabrLocalVolatility >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZabrLocalVolatilitySmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrSmileSection< ZabrLocalVolatility > *arg1 = (ZabrSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > tempshared1 ;
  ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrLocalVolatilitySmileSection" "', argument " "1"" of type '" "ZabrSmileSection< ZabrLocalVolatility > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrLocalVolatilitySmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrLocalVolatilitySmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Size arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  size_t val5 ;
  int ecode5 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdSmileSection" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  size_t val6 ;
  int ecode6 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZabrFullFdSmileSection" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  ZabrSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (ZabrSmileSection< ZabrFullFd > *)new ZabrSmileSection< ZabrFullFd >((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrFullFdSmileSection", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrFullFdSmileSection__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZabrFullFdSmileSection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrFullFdSmileSection__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZabrFullFdSmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ZabrFullFdSmileSection__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ZabrFullFdSmileSection__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ZabrFullFdSmileSection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrFullFdSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Size const)\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n"
    "    ZabrSmileSection< ZabrFullFd >::ZabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZabrFullFdSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrSmileSection< ZabrFullFd > *arg1 = (ZabrSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > tempshared1 ;
  ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrFullFdSmileSection" "', argument " "1"" of type '" "ZabrSmileSection< ZabrFullFd > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrFullFdSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrFullFdSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrShortMaturityLognormalInterpolatedSmileSection", 0, 20, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_9(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_19(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_8(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_18(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_7(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_17(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_6(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_16(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_5(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_15(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_4(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_14(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_3(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_13(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_2(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_12(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_1(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_11(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_0(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection__SWIG_10(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrShortMaturityLognormalInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_alpha" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_beta" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_nu" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_rho" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_maxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_maxError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrShortMaturityLognormalInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrShortMaturityLognormalInterpolatedSmileSection" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityLognormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *)new ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrShortMaturityNormalInterpolatedSmileSection", 0, 20, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_9(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_19(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_8(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_18(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_7(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_17(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_6(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_16(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_5(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_15(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_4(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_14(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_3(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_13(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_2(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_12(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_1(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_11(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_0(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection__SWIG_10(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrShortMaturityNormalInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrShortMaturityNormal >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_alpha" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_beta" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_nu" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_rho" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_rmsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_rmsError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_maxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_maxError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrShortMaturityNormalInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *arg1 = (ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrShortMaturityNormalInterpolatedSmileSection" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrShortMaturityNormal> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrShortMaturityNormalInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrShortMaturityNormalInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *)new ZabrInterpolatedSmileSection< ZabrLocalVolatility >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrLocalVolatilityInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrLocalVolatilityInterpolatedSmileSection", 0, 20, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_9(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_19(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_8(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_18(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_7(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_17(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_6(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_16(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_5(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_15(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_4(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_14(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_3(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_13(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_2(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_12(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_1(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_11(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_0(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection__SWIG_10(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrLocalVolatilityInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrLocalVolatility >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_alpha" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_beta" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_nu" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_rho" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_rmsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_rmsError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_maxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_maxError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrLocalVolatilityInterpolatedSmileSection_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrLocalVolatilityInterpolatedSmileSection_endCriteria" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrLocalVolatility > const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrLocalVolatilityInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrLocalVolatility > *arg1 = (ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrLocalVolatilityInterpolatedSmileSection" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrLocalVolatility > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrLocalVolatility> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrLocalVolatility > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrLocalVolatilityInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrLocalVolatilityInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  DayCounter *arg20 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  if (!argp20) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "20"" of type '" "DayCounter const &""'"); 
  }
  arg20 = reinterpret_cast< DayCounter * >(argp20);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19,(DayCounter const &)*arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg19 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  void *argp19 ;
  int res19 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared19 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    int newmem = 0;
    res19 = SWIG_ConvertPtrAndOwn(swig_obj[18], &argp19, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "19"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp19) tempshared19 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19);
      arg19 = &tempshared19;
    } else {
      arg19 = (argp19) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp19) : &tempshared19;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18,(ext::shared_ptr< OptimizationMethod > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  ext::shared_ptr< EndCriteria > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  void *argp18 ;
  int res18 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared18 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    int newmem = 0;
    res18 = SWIG_ConvertPtrAndOwn(swig_obj[17], &argp18, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "18"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp18) tempshared18 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18);
      arg18 = &tempshared18;
    } else {
      arg18 = (argp18) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp18) : &tempshared18;
    }
  }
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,(ext::shared_ptr< EndCriteria > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_bool(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "16"" of type '" "bool""'");
  } 
  arg16 = static_cast< bool >(val16);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ZabrInterpolatedSmileSection< ZabrFullFd > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZabrFullFdInterpolatedSmileSection" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ZabrInterpolatedSmileSection< ZabrFullFd > *)new ZabrInterpolatedSmileSection< ZabrFullFd >((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > *smartresult = result ? new ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZabrFullFdInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZabrFullFdInterpolatedSmileSection", 0, 20, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_9(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_19(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_8(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_18(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_7(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_17(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_6(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_16(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_5(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_15(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_4(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_14(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_3(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_13(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_2(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_12(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_1(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_11(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_0(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = SWIG_ConvertPtr(argv[18], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          int res = SWIG_ConvertPtr(argv[19], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                          _v = SWIG_CheckState(res);
                                          if (_v) {
                                            return _wrap_new_ZabrFullFdInterpolatedSmileSection__SWIG_10(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZabrFullFdInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,Real)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real,bool)\n"
    "    ZabrInterpolatedSmileSection< ZabrFullFd >::ZabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_alpha" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_beta" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_nu" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_rho" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_rmsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_rmsError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_maxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_maxError" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZabrFullFdInterpolatedSmileSection_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZabrFullFdInterpolatedSmileSection_endCriteria" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((ZabrInterpolatedSmileSection< ZabrFullFd > const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZabrFullFdInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZabrInterpolatedSmileSection< ZabrFullFd > *arg1 = (ZabrInterpolatedSmileSection< ZabrFullFd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > tempshared1 ;
  ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZabrFullFdInterpolatedSmileSection" "', argument " "1"" of type '" "ZabrInterpolatedSmileSection< ZabrFullFd > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZabrInterpolatedSmileSection<ZabrFullFd> > * >(argp1);
      arg1 = const_cast< ZabrInterpolatedSmileSection< ZabrFullFd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZabrFullFdInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZabrFullFdInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  VolatilityType arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrSmileSection" "', argument " "5"" of type '" "VolatilityType""'");
  } 
  arg5 = static_cast< VolatilityType >(val5);
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection(arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  VolatilityType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrSmileSection" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_NoArbSabrSmileSection" "', argument " "6"" of type '" "VolatilityType""'");
  } 
  arg6 = static_cast< VolatilityType >(val6);
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrSmileSection" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate arg2 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  NoArbSabrSmileSection *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrSmileSection" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (NoArbSabrSmileSection *)new NoArbSabrSmileSection((Date const &)*arg1,arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoArbSabrSmileSection", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NoArbSabrSmileSection__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NoArbSabrSmileSection__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_NoArbSabrSmileSection__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_NoArbSabrSmileSection__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_NoArbSabrSmileSection__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_NoArbSabrSmileSection__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_NoArbSabrSmileSection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoArbSabrSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,Real const,VolatilityType)\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &,Real const)\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Time,Rate,std::vector< Real,std::allocator< Real > > const &)\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Real const,VolatilityType)\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Real const)\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n"
    "    NoArbSabrSmileSection::NoArbSabrSmileSection(Date const &,Rate,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoArbSabrSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrSmileSection *arg1 = (NoArbSabrSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrSmileSection > tempshared1 ;
  ext::shared_ptr< NoArbSabrSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoArbSabrSmileSection" "', argument " "1"" of type '" "NoArbSabrSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NoArbSabrSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NoArbSabrSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NoArbSabrSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoArbSabrSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NoArbSabrSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoArbSabrSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  DayCounter *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared16 ;
  void *argp17 ;
  int res17 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared17 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "16"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16) : &tempshared16;
    }
  }
  {
    int newmem = 0;
    res17 = SWIG_ConvertPtrAndOwn(swig_obj[16], &argp17, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "17"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp17) tempshared17 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      arg17 = &tempshared17;
    } else {
      arg17 = (argp17) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17) : &tempshared17;
    }
  }
  res18 = SWIG_ConvertPtr(swig_obj[17], &argp18, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "18"" of type '" "DayCounter const &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "18"" of type '" "DayCounter const &""'"); 
  }
  arg18 = reinterpret_cast< DayCounter * >(argp18);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > const &)*arg17,(DayCounter const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared16 ;
  void *argp17 ;
  int res17 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared17 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "16"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16) : &tempshared16;
    }
  }
  {
    int newmem = 0;
    res17 = SWIG_ConvertPtrAndOwn(swig_obj[16], &argp17, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "17"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp17) tempshared17 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      arg17 = &tempshared17;
    } else {
      arg17 = (argp17) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17) : &tempshared17;
    }
  }
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > const &)*arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared16 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "16"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16) : &tempshared16;
    }
  }
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Handle< Quote > *arg5 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Handle< Quote > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Handle< Quote > const &)*arg5,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  DayCounter *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared16 ;
  void *argp17 ;
  int res17 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared17 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "16"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16) : &tempshared16;
    }
  }
  {
    int newmem = 0;
    res17 = SWIG_ConvertPtrAndOwn(swig_obj[16], &argp17, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "17"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp17) tempshared17 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      arg17 = &tempshared17;
    } else {
      arg17 = (argp17) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17) : &tempshared17;
    }
  }
  res18 = SWIG_ConvertPtr(swig_obj[17], &argp18, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "18"" of type '" "DayCounter const &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "18"" of type '" "DayCounter const &""'"); 
  }
  arg18 = reinterpret_cast< DayCounter * >(argp18);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > const &)*arg17,(DayCounter const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg17 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared16 ;
  void *argp17 ;
  int res17 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared17 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "16"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16) : &tempshared16;
    }
  }
  {
    int newmem = 0;
    res17 = SWIG_ConvertPtrAndOwn(swig_obj[16], &argp17, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "17"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp17) tempshared17 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17);
      arg17 = &tempshared17;
    } else {
      arg17 = (argp17) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp17) : &tempshared17;
    }
  }
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16,(ext::shared_ptr< OptimizationMethod > const &)*arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  ext::shared_ptr< EndCriteria > *arg16 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared16 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "16"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp16) : &tempshared16;
    }
  }
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(ext::shared_ptr< EndCriteria > const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Rate *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  bool arg4 ;
  Volatility *arg5 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg6 = 0 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Rate temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility temp5 ;
  double val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  NoArbSabrInterpolatedSmileSection *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "2"" of type '" "Rate""'");
  } 
  temp2 = static_cast< Rate >(val2);
  arg2 = &temp2;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "5"" of type '" "Volatility""'");
  } 
  temp5 = static_cast< Volatility >(val5);
  arg5 = &temp5;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "6"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_NoArbSabrInterpolatedSmileSection" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (NoArbSabrInterpolatedSmileSection *)new NoArbSabrInterpolatedSmileSection((Date const &)*arg1,(Rate const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3,arg4,(Volatility const &)*arg5,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > *smartresult = result ? new ext::shared_ptr<  NoArbSabrInterpolatedSmileSection >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoArbSabrInterpolatedSmileSection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[19] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoArbSabrInterpolatedSmileSection", 0, 18, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_8(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_17(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_7(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_16(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_6(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_15(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_5(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_14(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_4(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_13(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_3(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_12(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_2(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_11(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_1(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_10(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_0(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = SWIG_ConvertPtr(argv[16], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = SWIG_ConvertPtr(argv[17], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_NoArbSabrInterpolatedSmileSection__SWIG_9(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoArbSabrInterpolatedSmileSection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Handle< Quote > const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Handle< Quote > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real,Real,Real,Real)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,DayCounter const &)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool,ext::shared_ptr< EndCriteria > const &)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool,bool,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real,bool)\n"
    "    NoArbSabrInterpolatedSmileSection::NoArbSabrInterpolatedSmileSection(Date const &,Rate const &,std::vector< Rate,std::allocator< Rate > > const &,bool,Volatility const &,std::vector< Volatility,std::allocator< Volatility > > const &,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_alpha" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_beta" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_nu" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_rho" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_rmsError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_rmsError" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->rmsError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_maxError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_maxError" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NoArbSabrInterpolatedSmileSection const *)arg1)->maxError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoArbSabrInterpolatedSmileSection_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoArbSabrInterpolatedSmileSection_endCriteria" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((NoArbSabrInterpolatedSmileSection const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NoArbSabrInterpolatedSmileSection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoArbSabrInterpolatedSmileSection *arg1 = (NoArbSabrInterpolatedSmileSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection > tempshared1 ;
  ext::shared_ptr< NoArbSabrInterpolatedSmileSection > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoArbSabrInterpolatedSmileSection" "', argument " "1"" of type '" "NoArbSabrInterpolatedSmileSection *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NoArbSabrInterpolatedSmileSection > * >(argp1);
      arg1 = const_cast< NoArbSabrInterpolatedSmileSection * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoArbSabrInterpolatedSmileSection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoArbSabrInterpolatedSmileSection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_sabrVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  VolatilityType 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 ;
  int val8 ;
  int ecode8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sabrVolatility" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sabrVolatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sabrVolatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sabrVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sabrVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "sabrVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "sabrVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "sabrVolatility" "', argument " "8"" of type '" "VolatilityType""'");
  } 
  arg8 = static_cast< VolatilityType >(val8);
  {
    try {
      result = (Real)sabrVolatility(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sabrVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sabrVolatility" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sabrVolatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sabrVolatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sabrVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sabrVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "sabrVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "sabrVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)sabrVolatility(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sabrVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "sabrVolatility", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_sabrVolatility__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_sabrVolatility__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'sabrVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    sabrVolatility(Rate,Rate,Time,Real,Real,Real,Real,VolatilityType)\n"
    "    sabrVolatility(Rate,Rate,Time,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_shiftedSabrVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  VolatilityType arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "shiftedSabrVolatility" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shiftedSabrVolatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "shiftedSabrVolatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "shiftedSabrVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "shiftedSabrVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "shiftedSabrVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "shiftedSabrVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "shiftedSabrVolatility" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "shiftedSabrVolatility" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  {
    try {
      result = (Real)shiftedSabrVolatility(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_shiftedSabrVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real 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 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "shiftedSabrVolatility" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shiftedSabrVolatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "shiftedSabrVolatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "shiftedSabrVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "shiftedSabrVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "shiftedSabrVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "shiftedSabrVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "shiftedSabrVolatility" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Real)shiftedSabrVolatility(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_shiftedSabrVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "shiftedSabrVolatility", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_shiftedSabrVolatility__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_shiftedSabrVolatility__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'shiftedSabrVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    shiftedSabrVolatility(Rate,Rate,Time,Real,Real,Real,Real,Real,VolatilityType)\n"
    "    shiftedSabrVolatility(Rate,Rate,Time,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sabrFlochKennedyVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "sabrFlochKennedyVolatility", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sabrFlochKennedyVolatility" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sabrFlochKennedyVolatility" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sabrFlochKennedyVolatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sabrFlochKennedyVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sabrFlochKennedyVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "sabrFlochKennedyVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "sabrFlochKennedyVolatility" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)sabrFlochKennedyVolatility(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationErrorTuple(PyObject *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 *swig_obj[3] ;
  ext::tuple< Real,Real,Real > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CalibrationErrorTuple", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalibrationErrorTuple" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CalibrationErrorTuple" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CalibrationErrorTuple" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (ext::tuple< Real,Real,Real > *)new ext::tuple< Real,Real,Real >(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ext__tupleT_double_double_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationErrorTuple_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationErrorTuple_first" "', argument " "1"" of type '" "ext::tuple< Real,Real,Real > const *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,Real > * >(argp1);
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__first((ext::tuple< double,double,double > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationErrorTuple_second(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationErrorTuple_second" "', argument " "1"" of type '" "ext::tuple< Real,Real,Real > const *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,Real > * >(argp1);
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__second((ext::tuple< double,double,double > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationErrorTuple_third(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationErrorTuple_third" "', argument " "1"" of type '" "ext::tuple< Real,Real,Real > const *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,Real > * >(argp1);
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_Real_Sg__third((ext::tuple< double,double,double > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibrationErrorTuple(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,Real > *arg1 = (ext::tuple< Real,Real,Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibrationErrorTuple" "', argument " "1"" of type '" "ext::tuple< Real,Real,Real > *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,Real > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibrationErrorTuple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__tupleT_double_double_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CalibrationErrorTuple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  ext::shared_ptr< OptimizationMethod > *arg10 = 0 ;
  EndCriteria *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared10 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared11 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "6"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationType""'");
  } 
  arg6 = static_cast< AndreasenHugeVolatilityInterpl::CalibrationType >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "10"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp10) : &tempshared10;
    }
  }
  {
    int newmem = 0;
    res11 = SWIG_ConvertPtrAndOwn(swig_obj[10], &argp11, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "11"" of type '" "EndCriteria const &""'");
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "11"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared11 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp11);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp11);
      arg11 = const_cast< EndCriteria * >(tempshared11.get());
    } else {
      arg11 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp11)->get());
    }
  }
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,(ext::shared_ptr< OptimizationMethod > const &)*arg10,(EndCriteria const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  ext::shared_ptr< OptimizationMethod > *arg10 = 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 val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared10 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "6"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationType""'");
  } 
  arg6 = static_cast< AndreasenHugeVolatilityInterpl::CalibrationType >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "10"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp10) : &tempshared10;
    }
  }
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,(ext::shared_ptr< OptimizationMethod > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "6"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationType""'");
  } 
  arg6 = static_cast< AndreasenHugeVolatilityInterpl::CalibrationType >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "6"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationType""'");
  } 
  arg6 = static_cast< AndreasenHugeVolatilityInterpl::CalibrationType >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  Size arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "6"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationType""'");
  } 
  arg6 = static_cast< AndreasenHugeVolatilityInterpl::CalibrationType >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  AndreasenHugeVolatilityInterpl::CalibrationType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "6"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationType""'");
  } 
  arg6 = static_cast< AndreasenHugeVolatilityInterpl::CalibrationType >(val6);
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  AndreasenHugeVolatilityInterpl::InterpolationType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "5"" of type '" "AndreasenHugeVolatilityInterpl::InterpolationType""'");
  } 
  arg5 = static_cast< AndreasenHugeVolatilityInterpl::InterpolationType >(val5);
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl::CalibrationSet *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  AndreasenHugeVolatilityInterpl *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl::CalibrationSet const &""'"); 
  }
  arg1 = reinterpret_cast< AndreasenHugeVolatilityInterpl::CalibrationSet * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AndreasenHugeVolatilityInterpl" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  {
    try {
      result = (AndreasenHugeVolatilityInterpl *)new AndreasenHugeVolatilityInterpl((AndreasenHugeVolatilityInterpl::CalibrationSet const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityInterpl > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityInterpl >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityInterpl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AndreasenHugeVolatilityInterpl", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_AndreasenHugeVolatilityInterpl__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AndreasenHugeVolatilityInterpl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType,AndreasenHugeVolatilityInterpl::CalibrationType,Size,Real,Real,ext::shared_ptr< OptimizationMethod > const &,EndCriteria const &)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType,AndreasenHugeVolatilityInterpl::CalibrationType,Size,Real,Real,ext::shared_ptr< OptimizationMethod > const &)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType,AndreasenHugeVolatilityInterpl::CalibrationType,Size,Real,Real)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType,AndreasenHugeVolatilityInterpl::CalibrationType,Size,Real)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType,AndreasenHugeVolatilityInterpl::CalibrationType,Size)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType,AndreasenHugeVolatilityInterpl::CalibrationType)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,AndreasenHugeVolatilityInterpl::InterpolationType)\n"
    "    AndreasenHugeVolatilityInterpl::AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl::CalibrationSet const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_maxDate" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((AndreasenHugeVolatilityInterpl const *)arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_minStrike" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_maxStrike" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_fwd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AndreasenHugeVolatilityInterpl_fwd", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_fwd" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AndreasenHugeVolatilityInterpl_fwd" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)arg1)->fwd(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_riskFreeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_riskFreeRate" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((AndreasenHugeVolatilityInterpl const *)arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_calibrationError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< ext::tuple< double,double,double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_calibrationError" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((AndreasenHugeVolatilityInterpl const *)arg1)->calibrationError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ext::tuple< Real,Real,Real >(result)), SWIGTYPE_p_ext__tupleT_double_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_optionPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Option::Type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AndreasenHugeVolatilityInterpl_optionPrice", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_optionPrice" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AndreasenHugeVolatilityInterpl_optionPrice" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AndreasenHugeVolatilityInterpl_optionPrice" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AndreasenHugeVolatilityInterpl_optionPrice" "', argument " "4"" of type '" "Option::Type""'");
  } 
  arg4 = static_cast< Option::Type >(val4);
  {
    try {
      result = (Real)((AndreasenHugeVolatilityInterpl const *)arg1)->optionPrice(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AndreasenHugeVolatilityInterpl_localVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Volatility result;
  
  if (!SWIG_Python_UnpackTuple(args, "AndreasenHugeVolatilityInterpl_localVol", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AndreasenHugeVolatilityInterpl_localVol" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AndreasenHugeVolatilityInterpl_localVol" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AndreasenHugeVolatilityInterpl_localVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Volatility)((AndreasenHugeVolatilityInterpl const *)arg1)->localVol(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AndreasenHugeVolatilityInterpl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityInterpl *arg1 = (AndreasenHugeVolatilityInterpl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AndreasenHugeVolatilityInterpl" "', argument " "1"" of type '" "AndreasenHugeVolatilityInterpl *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityInterpl * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AndreasenHugeVolatilityInterpl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AndreasenHugeVolatilityInterpl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityAdapter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  AndreasenHugeVolatilityAdapter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityAdapter" "', argument " "1"" of type '" "ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AndreasenHugeVolatilityAdapter" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (AndreasenHugeVolatilityAdapter *)new AndreasenHugeVolatilityAdapter((ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityAdapter > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityAdapter >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityAdapter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempshared1 ;
  AndreasenHugeVolatilityAdapter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeVolatilityAdapter" "', argument " "1"" of type '" "ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AndreasenHugeVolatilityAdapter *)new AndreasenHugeVolatilityAdapter((ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeVolatilityAdapter > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeVolatilityAdapter >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AndreasenHugeVolatilityAdapter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AndreasenHugeVolatilityAdapter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AndreasenHugeVolatilityAdapter__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AndreasenHugeVolatilityAdapter__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AndreasenHugeVolatilityAdapter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AndreasenHugeVolatilityAdapter::AndreasenHugeVolatilityAdapter(ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &,Real)\n"
    "    AndreasenHugeVolatilityAdapter::AndreasenHugeVolatilityAdapter(ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AndreasenHugeVolatilityAdapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeVolatilityAdapter *arg1 = (AndreasenHugeVolatilityAdapter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityAdapter > tempshared1 ;
  ext::shared_ptr< AndreasenHugeVolatilityAdapter > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AndreasenHugeVolatilityAdapter" "', argument " "1"" of type '" "AndreasenHugeVolatilityAdapter *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AndreasenHugeVolatilityAdapter > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AndreasenHugeVolatilityAdapter > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityAdapter * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AndreasenHugeVolatilityAdapter > * >(argp1);
      arg1 = const_cast< AndreasenHugeVolatilityAdapter * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AndreasenHugeVolatilityAdapter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AndreasenHugeVolatilityAdapter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AndreasenHugeLocalVolAdapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeVolatilityInterpl > tempshared1 ;
  PyObject *swig_obj[1] ;
  AndreasenHugeLocalVolAdapter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AndreasenHugeLocalVolAdapter" "', argument " "1"" of type '" "ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< AndreasenHugeVolatilityInterpl > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AndreasenHugeLocalVolAdapter *)new AndreasenHugeLocalVolAdapter((ext::shared_ptr< AndreasenHugeVolatilityInterpl > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AndreasenHugeLocalVolAdapter > *smartresult = result ? new ext::shared_ptr<  AndreasenHugeLocalVolAdapter >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AndreasenHugeLocalVolAdapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AndreasenHugeLocalVolAdapter *arg1 = (AndreasenHugeLocalVolAdapter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AndreasenHugeLocalVolAdapter > tempshared1 ;
  ext::shared_ptr< AndreasenHugeLocalVolAdapter > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AndreasenHugeLocalVolAdapter" "', argument " "1"" of type '" "AndreasenHugeLocalVolAdapter *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AndreasenHugeLocalVolAdapter > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AndreasenHugeLocalVolAdapter > * >(argp1);
      arg1 = const_cast< AndreasenHugeLocalVolAdapter * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AndreasenHugeLocalVolAdapter > * >(argp1);
      arg1 = const_cast< AndreasenHugeLocalVolAdapter * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AndreasenHugeLocalVolAdapter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AndreasenHugeLocalVolAdapter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonBlackVolSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  AnalyticHestonEngine::Integration *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  HestonBlackVolSurface *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_HestonModel_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonBlackVolSurface" "', argument " "1"" of type '" "Handle< HestonModel > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonBlackVolSurface" "', argument " "1"" of type '" "Handle< HestonModel > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HestonBlackVolSurface" "', argument " "2"" of type '" "AnalyticHestonEngine::ComplexLogFormula""'");
  } 
  arg2 = static_cast< AnalyticHestonEngine::ComplexLogFormula >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_AnalyticHestonEngine__Integration,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonBlackVolSurface" "', argument " "3"" of type '" "AnalyticHestonEngine::Integration const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonBlackVolSurface" "', argument " "3"" of type '" "AnalyticHestonEngine::Integration const &""'"); 
  }
  arg3 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp3);
  {
    try {
      result = (HestonBlackVolSurface *)new HestonBlackVolSurface((Handle< HestonModel > const &)*arg1,arg2,(AnalyticHestonEngine::Integration const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonBlackVolSurface > *smartresult = result ? new ext::shared_ptr<  HestonBlackVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonBlackVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonBlackVolSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  HestonBlackVolSurface *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_HestonModel_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonBlackVolSurface" "', argument " "1"" of type '" "Handle< HestonModel > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonBlackVolSurface" "', argument " "1"" of type '" "Handle< HestonModel > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HestonBlackVolSurface" "', argument " "2"" of type '" "AnalyticHestonEngine::ComplexLogFormula""'");
  } 
  arg2 = static_cast< AnalyticHestonEngine::ComplexLogFormula >(val2);
  {
    try {
      result = (HestonBlackVolSurface *)new HestonBlackVolSurface((Handle< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonBlackVolSurface > *smartresult = result ? new ext::shared_ptr<  HestonBlackVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonBlackVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonBlackVolSurface__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  HestonBlackVolSurface *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_HestonModel_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonBlackVolSurface" "', argument " "1"" of type '" "Handle< HestonModel > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonBlackVolSurface" "', argument " "1"" of type '" "Handle< HestonModel > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (HestonBlackVolSurface *)new HestonBlackVolSurface((Handle< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonBlackVolSurface > *smartresult = result ? new ext::shared_ptr<  HestonBlackVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonBlackVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonBlackVolSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonBlackVolSurface", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_HestonModel_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HestonBlackVolSurface__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_HestonModel_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HestonBlackVolSurface__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_HestonModel_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_HestonBlackVolSurface__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonBlackVolSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonBlackVolSurface::HestonBlackVolSurface(Handle< HestonModel > const &,AnalyticHestonEngine::ComplexLogFormula const,AnalyticHestonEngine::Integration const &)\n"
    "    HestonBlackVolSurface::HestonBlackVolSurface(Handle< HestonModel > const &,AnalyticHestonEngine::ComplexLogFormula const)\n"
    "    HestonBlackVolSurface::HestonBlackVolSurface(Handle< HestonModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HestonBlackVolSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonBlackVolSurface *arg1 = (HestonBlackVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonBlackVolSurface > tempshared1 ;
  ext::shared_ptr< HestonBlackVolSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonBlackVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonBlackVolSurface" "', argument " "1"" of type '" "HestonBlackVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonBlackVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonBlackVolSurface > * >(argp1);
      arg1 = const_cast< HestonBlackVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonBlackVolSurface > * >(argp1);
      arg1 = const_cast< HestonBlackVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonBlackVolSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HestonBlackVolSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonBlackVolSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CmsMarket(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Period,std::allocator< Period > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg4 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  CmsMarket *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CmsMarket", 6, 6, swig_obj)) SWIG_fail;
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CmsMarket" "', argument " "1"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarket" "', argument " "1"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *ptr = (std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CmsMarket" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarket" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CmsMarket" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CmsMarket" "', argument " "4"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarket" "', argument " "4"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CmsMarket" "', argument " "5"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarket" "', argument " "5"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CmsMarket" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarket" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (CmsMarket *)new CmsMarket((std::vector< Period,std::allocator< Period > > const &)*arg1,(std::vector< ext::shared_ptr< SwapIndex >,std::allocator< ext::shared_ptr< SwapIndex > > > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg4,(std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsMarket > *smartresult = result ? new ext::shared_ptr<  CmsMarket >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_reprice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_reprice", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_reprice" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_reprice" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_reprice" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CmsMarket_reprice" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->reprice((Handle< SwaptionVolatilityStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_swapTenors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket const > tempshared1 ;
  ext::shared_ptr< CmsMarket const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_swapTenors" "', argument " "1"" of type '" "CmsMarket const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Period,std::allocator< Period > > *) &((CmsMarket const *)arg1)->swapTenors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Period,std::allocator< Period > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_swapLengths(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket const > tempshared1 ;
  ext::shared_ptr< CmsMarket const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_swapLengths" "', argument " "1"" of type '" "CmsMarket const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Period,std::allocator< Period > > *) &((CmsMarket const *)arg1)->swapLengths();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Period,std::allocator< Period > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_impliedCmsSpreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_impliedCmsSpreads" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Matrix *) &(arg1)->impliedCmsSpreads();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_spreadErrors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_spreadErrors" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Matrix *) &(arg1)->spreadErrors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_browse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket const > tempshared1 ;
  ext::shared_ptr< CmsMarket const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_browse" "', argument " "1"" of type '" "CmsMarket const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CmsMarket const *)arg1)->browse();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedSpreadError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_weightedSpreadError", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_weightedSpreadError" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_weightedSpreadError" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_weightedSpreadError" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (Real)(arg1)->weightedSpreadError((Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedSpotNpvError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_weightedSpotNpvError", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_weightedSpotNpvError" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_weightedSpotNpvError" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_weightedSpotNpvError" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (Real)(arg1)->weightedSpotNpvError((Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedFwdNpvError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_weightedFwdNpvError", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_weightedFwdNpvError" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_weightedFwdNpvError" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_weightedFwdNpvError" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (Real)(arg1)->weightedFwdNpvError((Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedSpreadErrors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_weightedSpreadErrors", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_weightedSpreadErrors" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_weightedSpreadErrors" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_weightedSpreadErrors" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (arg1)->weightedSpreadErrors((Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedSpotNpvErrors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_weightedSpotNpvErrors", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_weightedSpotNpvErrors" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_weightedSpotNpvErrors" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_weightedSpotNpvErrors" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (arg1)->weightedSpotNpvErrors((Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarket_weightedFwdNpvErrors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  Matrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsMarket_weightedFwdNpvErrors", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarket_weightedFwdNpvErrors" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarket_weightedFwdNpvErrors" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarket_weightedFwdNpvErrors" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (arg1)->weightedFwdNpvErrors((Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsMarket(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarket *arg1 = (CmsMarket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared1 ;
  ext::shared_ptr< CmsMarket > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsMarket" "', argument " "1"" of type '" "CmsMarket *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsMarket > * >(argp1);
      arg1 = const_cast< CmsMarket * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsMarket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CmsMarket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CmsMarketCalibration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  ext::shared_ptr< CmsMarket > *arg2 = 0 ;
  Matrix *arg3 = 0 ;
  CmsMarketCalibration::CalibrationType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< CmsMarket > tempshared2 ;
  Matrix temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  CmsMarketCalibration *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CmsMarketCalibration", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CmsMarketCalibration" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarketCalibration" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CmsMarket_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CmsMarketCalibration" "', argument " "2"" of type '" "ext::shared_ptr< CmsMarket > &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< CmsMarket > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< CmsMarket > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< CmsMarket > * >(argp2) : &tempshared2;
    }
  }
  {
    if (PyTuple_Check(swig_obj[2]) || PyList_Check(swig_obj[2])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[2]) ?
      PyTuple_Size(swig_obj[2]) :
        PyList_Size(swig_obj[2]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[2],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp3 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[2],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp3[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp3[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CmsMarketCalibration" "', argument " "3"" of type '" "Matrix const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsMarketCalibration" "', argument " "3"" of type '" "Matrix const &""'"); 
      }
      arg3 = reinterpret_cast< Matrix * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CmsMarketCalibration" "', argument " "4"" of type '" "CmsMarketCalibration::CalibrationType""'");
  } 
  arg4 = static_cast< CmsMarketCalibration::CalibrationType >(val4);
  {
    try {
      result = (CmsMarketCalibration *)new CmsMarketCalibration(*arg1,*arg2,(Matrix const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CmsMarketCalibration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_compute__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Array *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  Array temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Array result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_compute" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarketCalibration_compute" "', argument " "2"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsMarketCalibration_compute" "', argument " "3"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3) : &tempshared3;
    }
  }
  {
    if (ArrayFromSequence(swig_obj[3],&temp4)) {
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsMarketCalibration_compute" "', argument " "4"" of type '" "Array const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarketCalibration_compute" "', argument " "4"" of type '" "Array const &""'"); 
      }
      arg4 = reinterpret_cast< Array * >(argp4);
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsMarketCalibration_compute" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (arg1)->compute((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Array const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_compute__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Matrix result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_compute" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarketCalibration_compute" "', argument " "2"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsMarketCalibration_compute" "', argument " "3"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3) : &tempshared3;
    }
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsMarketCalibration_compute" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarketCalibration_compute" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsMarketCalibration_compute" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CmsMarketCalibration_compute" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (arg1)->compute((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_compute__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Matrix result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_compute" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarketCalibration_compute" "', argument " "2"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsMarketCalibration_compute" "', argument " "3"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3) : &tempshared3;
    }
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsMarketCalibration_compute" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarketCalibration_compute" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsMarketCalibration_compute" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (arg1)->compute((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_compute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsMarketCalibration_compute", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CmsMarketCalibration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              Size size = PySequence_Size(argv[3]);
              if (size == 0) {
                _v = 1;
              } else {
                PyObject* o = PySequence_GetItem(argv[3],0);
                if (PyNumber_Check(o))
                _v = 1;
                else
                _v = 0;
                Py_DECREF(o);
              }
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CmsMarketCalibration_compute__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CmsMarketCalibration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CmsMarketCalibration_compute__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CmsMarketCalibration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CmsMarketCalibration_compute__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsMarketCalibration_compute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CmsMarketCalibration::compute(ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Array const &,bool)\n"
    "    CmsMarketCalibration::compute(ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Matrix const &,bool,Real const)\n"
    "    CmsMarketCalibration::compute(ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Matrix const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_computeParametric__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Matrix result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "2"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "3"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3) : &tempshared3;
    }
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarketCalibration_computeParametric" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (arg1)->computeParametric((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_computeParametric__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  ext::shared_ptr< EndCriteria > *arg2 = 0 ;
  ext::shared_ptr< OptimizationMethod > *arg3 = 0 ;
  Matrix *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EndCriteria > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  Matrix temp4 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Matrix result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "2"" of type '" "ext::shared_ptr< EndCriteria > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EndCriteria > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "3"" of type '" "ext::shared_ptr< OptimizationMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< OptimizationMethod > * >(argp3) : &tempshared3;
    }
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg4 = &temp4;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "4"" of type '" "Matrix const &""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsMarketCalibration_computeParametric" "', argument " "4"" of type '" "Matrix const &""'"); 
      }
      arg4 = reinterpret_cast< Matrix * >(argp4);
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsMarketCalibration_computeParametric" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (arg1)->computeParametric((ext::shared_ptr< EndCriteria > const &)*arg2,(ext::shared_ptr< OptimizationMethod > const &)*arg3,(Matrix const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_computeParametric(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsMarketCalibration_computeParametric", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CmsMarketCalibration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CmsMarketCalibration_computeParametric__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CmsMarketCalibration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CmsMarketCalibration_computeParametric__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsMarketCalibration_computeParametric'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CmsMarketCalibration::computeParametric(ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Matrix const &,bool,Real const)\n"
    "    CmsMarketCalibration::computeParametric(ext::shared_ptr< EndCriteria > const &,ext::shared_ptr< OptimizationMethod > const &,Matrix const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_error(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_error" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    try {
      result = (Real)(arg1)->error();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsMarketCalibration_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsMarketCalibration_endCriteria" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    try {
      result = (EndCriteria::Type)(arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsMarketCalibration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsMarketCalibration *arg1 = (CmsMarketCalibration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CmsMarketCalibration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsMarketCalibration" "', argument " "1"" of type '" "CmsMarketCalibration *""'"); 
  }
  arg1 = reinterpret_cast< CmsMarketCalibration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsMarketCalibration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CmsMarketCalibration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CmsMarketCalibration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CashFlow_amount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CashFlow *arg1 = (CashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow const > tempshared1 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlow_amount" "', argument " "1"" of type '" "CashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CashFlow const *)arg1)->amount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlow_date(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CashFlow *arg1 = (CashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow const > tempshared1 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlow_date" "', argument " "1"" of type '" "CashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CashFlow const *)arg1)->date();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlow_hasOccurred__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CashFlow *arg1 = (CashFlow *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow const > tempshared1 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlow_hasOccurred" "', argument " "1"" of type '" "CashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlow_hasOccurred" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlow_hasOccurred" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)((CashFlow const *)arg1)->hasOccurred((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlow_hasOccurred__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CashFlow *arg1 = (CashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow const > tempshared1 ;
  ext::shared_ptr< CashFlow const > *smartarg1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlow_hasOccurred" "', argument " "1"" of type '" "CashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CashFlow const *)arg1)->hasOccurred();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlow_hasOccurred(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlow_hasOccurred", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CashFlow_hasOccurred__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CashFlow_hasOccurred__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlow_hasOccurred'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlow::hasOccurred(Date const &) const\n"
    "    CashFlow::hasOccurred() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CashFlow *arg1 = (CashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  ext::shared_ptr< CashFlow > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashFlow" "', argument " "1"" of type '" "CashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CashFlow > * >(argp1);
      arg1 = const_cast< CashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashFlow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Leg_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< CashFlow > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____bool__((std::vector< ext::shared_ptr< CashFlow > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____len__((std::vector< ext::shared_ptr< CashFlow > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Leg___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Leg___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Leg___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Leg___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Leg___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Leg___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Leg___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__setslice__(std::vector< ext::shared_ptr< CashFlow > >::difference_type,std::vector< ext::shared_ptr< CashFlow > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__setslice__(std::vector< ext::shared_ptr< CashFlow > >::difference_type,std::vector< ext::shared_ptr< CashFlow > >::difference_type,std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Leg___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Leg___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Leg___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Leg___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Leg___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__delitem__(std::vector< ext::shared_ptr< CashFlow > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CashFlow > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< CashFlow > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = *result ? new ext::shared_ptr<  CashFlow >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CashFlow > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Leg___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Leg___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__getitem__(std::vector< ext::shared_ptr< CashFlow > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Leg___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< CashFlow > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Leg___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Leg___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Leg___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::__setitem__(std::vector< ext::shared_ptr< CashFlow > >::difference_type,std::vector< ext::shared_ptr< CashFlow > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Leg_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__append(arg1,(ext::shared_ptr< CashFlow > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Leg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > > *)new std::vector< ext::shared_ptr< CashFlow > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Leg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Leg" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Leg" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > > *)new std::vector< ext::shared_ptr< CashFlow > >((std::vector< ext::shared_ptr< CashFlow > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< CashFlow > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CashFlow > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Leg_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Leg_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< CashFlow > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CashFlow > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< CashFlow > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_CashFlow_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Leg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Leg" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > > *)new std::vector< ext::shared_ptr< CashFlow > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Leg_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Leg_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::erase(std::vector< ext::shared_ptr< CashFlow > >::iterator)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::erase(std::vector< ext::shared_ptr< CashFlow > >::iterator,std::vector< ext::shared_ptr< CashFlow > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Leg__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg1 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< CashFlow > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Leg" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Leg" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > > *)new std::vector< ext::shared_ptr< CashFlow > >(arg1,(std::vector< ext::shared_ptr< CashFlow > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Leg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Leg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Leg__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Leg__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Leg__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Leg__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Leg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::vector()\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::vector(std::vector< ext::shared_ptr< CashFlow > > const &)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::vector(std::vector< ext::shared_ptr< CashFlow > >::size_type)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::vector(std::vector< ext::shared_ptr< CashFlow > >::size_type,std::vector< ext::shared_ptr< CashFlow > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Leg_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< CashFlow > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > >::value_type *) &((std::vector< ext::shared_ptr< CashFlow > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = *result ? new ext::shared_ptr<  CashFlow >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CashFlow > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CashFlow > >::value_type *) &((std::vector< ext::shared_ptr< CashFlow > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = *result ? new ext::shared_ptr<  CashFlow >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CashFlow > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Leg_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< CashFlow > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Leg_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< CashFlow > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Leg_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Leg_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::resize(std::vector< ext::shared_ptr< CashFlow > >::size_type)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::resize(std::vector< ext::shared_ptr< CashFlow > >::size_type,std::vector< ext::shared_ptr< CashFlow > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Leg_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< CashFlow > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CashFlow > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg3 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Leg_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Leg_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Leg_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CashFlow_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< CashFlow > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Leg_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Leg_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CashFlow > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Leg_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Leg_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::insert(std::vector< ext::shared_ptr< CashFlow > >::iterator,std::vector< ext::shared_ptr< CashFlow > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< CashFlow > >::insert(std::vector< ext::shared_ptr< CashFlow > >::iterator,std::vector< ext::shared_ptr< CashFlow > >::size_type,std::vector< ext::shared_ptr< CashFlow > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Leg_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Leg_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Leg_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CashFlow > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Leg_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Leg_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CashFlow > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Leg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow > > *arg1 = (std::vector< ext::shared_ptr< CashFlow > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Leg" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CashFlow > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Leg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Leg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_LegVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_iterator" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_Leg_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___nonzero__" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Leg_Sg____nonzero__((std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___bool__" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_Leg_Sg____bool__((std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___len__" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = std_vector_Sl_Leg_Sg____len__((std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___getslice__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LegVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *)std_vector_Sl_Leg_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___setslice__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LegVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg3 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___setslice__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LegVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val3);
  {
    std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LegVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LegVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_LegVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::__setslice__(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type)\n"
    "    std::vector< Leg >::__setslice__(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___delslice__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LegVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___delitem__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___getitem__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *)std_vector_Sl_Leg_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___setitem__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LegVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___setitem__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___delitem__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_LegVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LegVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::__delitem__(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type)\n"
    "    std::vector< Leg >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___getitem__" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *) &std_vector_Sl_Leg_Sg____getitem____SWIG_1((std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_LegVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LegVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Leg >::__getitem__(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector___setitem__" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type >(val2);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LegVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_Leg_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_LegVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LegVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LegVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > const &)\n"
    "    std::vector< Leg >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< Leg >::__setitem__(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_pop" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_Leg_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_append" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LegVector_append" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_append" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_Leg_Sg__append(arg1,(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< Leg > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< Leg > *)new std::vector< Leg >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< Leg > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegVector" "', argument " "1"" of type '" "std::vector< Leg > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegVector" "', argument " "1"" of type '" "std::vector< Leg > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< Leg > *)new std::vector< Leg >((std::vector< Leg > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_empty" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (bool)((std::vector< Leg > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_size" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = ((std::vector< Leg > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< Leg > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_swap" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LegVector_swap" "', argument " "2"" of type '" "std::vector< Leg > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_swap" "', argument " "2"" of type '" "std::vector< Leg > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Leg > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_begin" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_end" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_rbegin" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_rend" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_clear" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_get_allocator" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = ((std::vector< Leg > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< Leg > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LegVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val1);
  {
    try {
      result = (std::vector< Leg > *)new std::vector< Leg >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_pop_back" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_resize" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_erase" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Leg_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > arg2 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_erase" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_Leg_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_LegVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_LegVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::erase(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator)\n"
    "    std::vector< Leg >::erase(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_LegVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg1 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< Leg > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LegVector" "', argument " "1"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val1);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LegVector" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegVector" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< Leg > *)new std::vector< Leg >(arg1,(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LegVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LegVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LegVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LegVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LegVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::vector()\n"
    "    std::vector< Leg >::vector(std::vector< Leg > const &)\n"
    "    std::vector< Leg >::vector(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type)\n"
    "    std::vector< Leg >::vector(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_push_back" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LegVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_front" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *) &((std::vector< Leg > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_back" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *) &((std::vector< Leg > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_assign" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val2);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LegVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_resize" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val2);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LegVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LegVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LegVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::resize(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type)\n"
    "    std::vector< Leg >::resize(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_insert" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
    }
  }
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LegVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_Leg_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  SwigValueWrapper< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > arg2 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg3 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_insert" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LegVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LegVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val3);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LegVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LegVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_Leg_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LegVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LegVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_LegVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LegVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Leg >::insert(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)\n"
    "    std::vector< Leg >::insert(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type,std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LegVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "LegVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_reserve" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LegVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LegVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegVector_capacity" "', argument " "1"" of type '" "std::vector< Leg > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      result = ((std::vector< Leg > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LegVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Leg > *arg1 = (std::vector< Leg > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegVector" "', argument " "1"" of type '" "std::vector< Leg > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Leg > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_std__allocatorT_std__vectorT_ext__shared_ptrT_CashFlow_t_std__allocatorT_ext__shared_ptrT_CashFlow_t_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LegVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SimpleCashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SimpleCashFlow *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SimpleCashFlow", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SimpleCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SimpleCashFlow" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SimpleCashFlow" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (SimpleCashFlow *)new SimpleCashFlow(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SimpleCashFlow > *smartresult = result ? new ext::shared_ptr<  SimpleCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SimpleCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SimpleCashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpleCashFlow *arg1 = (SimpleCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SimpleCashFlow > tempshared1 ;
  ext::shared_ptr< SimpleCashFlow > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SimpleCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleCashFlow" "', argument " "1"" of type '" "SimpleCashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SimpleCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SimpleCashFlow > * >(argp1);
      arg1 = const_cast< SimpleCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SimpleCashFlow > * >(argp1);
      arg1 = const_cast< SimpleCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SimpleCashFlow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SimpleCashFlow_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SimpleCashFlow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Redemption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Redemption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Redemption", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Redemption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Redemption" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Redemption" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Redemption *)new Redemption(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Redemption > *smartresult = result ? new ext::shared_ptr<  Redemption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Redemption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Redemption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Redemption *arg1 = (Redemption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Redemption > tempshared1 ;
  ext::shared_ptr< Redemption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Redemption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Redemption" "', argument " "1"" of type '" "Redemption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Redemption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Redemption > * >(argp1);
      arg1 = const_cast< Redemption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Redemption > * >(argp1);
      arg1 = const_cast< Redemption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Redemption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Redemption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Redemption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AmortizingPayment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  AmortizingPayment *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AmortizingPayment", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AmortizingPayment" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AmortizingPayment" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingPayment" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (AmortizingPayment *)new AmortizingPayment(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AmortizingPayment > *smartresult = result ? new ext::shared_ptr<  AmortizingPayment >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AmortizingPayment_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AmortizingPayment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmortizingPayment *arg1 = (AmortizingPayment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmortizingPayment > tempshared1 ;
  ext::shared_ptr< AmortizingPayment > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmortizingPayment_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AmortizingPayment" "', argument " "1"" of type '" "AmortizingPayment *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AmortizingPayment > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AmortizingPayment > * >(argp1);
      arg1 = const_cast< AmortizingPayment * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AmortizingPayment > * >(argp1);
      arg1 = const_cast< AmortizingPayment * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AmortizingPayment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AmortizingPayment_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AmortizingPayment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IndexedCashFlow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< Index > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  bool arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Index > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  IndexedCashFlow *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IndexedCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Index_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IndexedCashFlow" "', argument " "2"" of type '" "ext::shared_ptr< Index > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Index > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Index > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Index > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IndexedCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexedCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IndexedCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexedCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_IndexedCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexedCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IndexedCashFlow" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (IndexedCashFlow *)new IndexedCashFlow(arg1,(ext::shared_ptr< Index > const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IndexedCashFlow > *smartresult = result ? new ext::shared_ptr<  IndexedCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndexedCashFlow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< Index > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Index > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  IndexedCashFlow *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IndexedCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Index_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IndexedCashFlow" "', argument " "2"" of type '" "ext::shared_ptr< Index > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Index > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Index > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Index > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IndexedCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexedCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IndexedCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexedCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_IndexedCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndexedCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (IndexedCashFlow *)new IndexedCashFlow(arg1,(ext::shared_ptr< Index > const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IndexedCashFlow > *smartresult = result ? new ext::shared_ptr<  IndexedCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndexedCashFlow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IndexedCashFlow", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_IndexedCashFlow__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Index_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_IndexedCashFlow__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IndexedCashFlow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IndexedCashFlow::IndexedCashFlow(Real,ext::shared_ptr< Index > const &,Date const &,Date const &,Date const &,bool)\n"
    "    IndexedCashFlow::IndexedCashFlow(Real,ext::shared_ptr< Index > const &,Date const &,Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_notional(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_notional" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((IndexedCashFlow const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_baseDate" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((IndexedCashFlow const *)arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_fixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_fixingDate" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((IndexedCashFlow const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_baseFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_baseFixing" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((IndexedCashFlow const *)arg1)->baseFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_indexFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_indexFixing" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((IndexedCashFlow const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Index > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_index" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((IndexedCashFlow const *)arg1)->index();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Index > *smartresult = result ? new ext::shared_ptr<  Index >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Index_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IndexedCashFlow_growthOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow const > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexedCashFlow_growthOnly" "', argument " "1"" of type '" "IndexedCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((IndexedCashFlow const *)arg1)->growthOnly();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IndexedCashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IndexedCashFlow *arg1 = (IndexedCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IndexedCashFlow > tempshared1 ;
  ext::shared_ptr< IndexedCashFlow > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndexedCashFlow" "', argument " "1"" of type '" "IndexedCashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IndexedCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IndexedCashFlow > * >(argp1);
      arg1 = const_cast< IndexedCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IndexedCashFlow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IndexedCashFlow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_indexed_cashflow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< IndexedCashFlow > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_indexed_cashflow" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_indexed_cashflow((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IndexedCashFlow > *smartresult = result ? new ext::shared_ptr<  IndexedCashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IndexedCashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_nominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_nominal" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Coupon const *)arg1)->nominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accrualStartDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_accrualStartDate" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Coupon const *)arg1)->accrualStartDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accrualEndDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_accrualEndDate" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Coupon const *)arg1)->accrualEndDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_referencePeriodStart(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_referencePeriodStart" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Coupon const *)arg1)->referencePeriodStart();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_referencePeriodEnd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_referencePeriodEnd" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Coupon const *)arg1)->referencePeriodEnd();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_exCouponDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_exCouponDate" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Coupon const *)arg1)->exCouponDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_rate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_rate" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Coupon const *)arg1)->rate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accrualPeriod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_accrualPeriod" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Time)((Coupon const *)arg1)->accrualPeriod();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accrualDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BigInteger result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_accrualDays" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BigInteger)((Coupon const *)arg1)->accrualDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_dayCounter" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Coupon const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Coupon_accruedAmount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon const > tempshared1 ;
  ext::shared_ptr< Coupon const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Coupon_accruedAmount", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coupon_accruedAmount" "', argument " "1"" of type '" "Coupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Coupon_accruedAmount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Coupon_accruedAmount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)((Coupon const *)arg1)->accruedAmount((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Coupon *arg1 = (Coupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Coupon > tempshared1 ;
  ext::shared_ptr< Coupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Coupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Coupon" "', argument " "1"" of type '" "Coupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Coupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Coupon > * >(argp1);
      arg1 = const_cast< Coupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Coupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Coupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_as_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Coupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Coupon > *smartresult = result ? new ext::shared_ptr<  Coupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Coupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Rate arg3 ;
  DayCounter *arg4 = 0 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  Date const &arg7_defvalue = Date() ;
  Date *arg7 = (Date *) &arg7_defvalue ;
  Date const &arg8_defvalue = Date() ;
  Date *arg8 = (Date *) &arg8_defvalue ;
  Date const &arg9_defvalue = Date() ;
  Date *arg9 = (Date *) &arg9_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  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 ;
  char * kwnames[] = {
    (char *)"paymentDate",  (char *)"nominal",  (char *)"rate",  (char *)"dayCounter",  (char *)"startDate",  (char *)"endDate",  (char *)"refPeriodStart",  (char *)"refPeriodEnd",  (char *)"exCouponDate",  NULL 
  };
  FixedRateCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOO:new_FixedRateCoupon", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateCoupon" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateCoupon" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateCoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateCoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FixedRateCoupon" "', argument " "7"" of type '" "Date const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "7"" of type '" "Date const &""'"); 
    }
    arg7 = reinterpret_cast< Date * >(argp7);
  }
  if (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FixedRateCoupon" "', argument " "8"" of type '" "Date const &""'"); 
    }
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "8"" of type '" "Date const &""'"); 
    }
    arg8 = reinterpret_cast< Date * >(argp8);
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    arg9 = reinterpret_cast< Date * >(argp9);
  }
  {
    try {
      result = (FixedRateCoupon *)new FixedRateCoupon((Date const &)*arg1,arg2,arg3,(DayCounter const &)*arg4,(Date const &)*arg5,(Date const &)*arg6,(Date const &)*arg7,(Date const &)*arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateCoupon > *smartresult = result ? new ext::shared_ptr<  FixedRateCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedRateCoupon_interestRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateCoupon *arg1 = (FixedRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateCoupon const > tempshared1 ;
  ext::shared_ptr< FixedRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  InterestRate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateCoupon_interestRate" "', argument " "1"" of type '" "FixedRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FixedRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FixedRateCoupon > * >(argp1);
      arg1 = const_cast< FixedRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FixedRateCoupon > * >(argp1);
      arg1 = const_cast< FixedRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FixedRateCoupon const *)arg1)->interestRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedRateCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateCoupon *arg1 = (FixedRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateCoupon > tempshared1 ;
  ext::shared_ptr< FixedRateCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedRateCoupon" "', argument " "1"" of type '" "FixedRateCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedRateCoupon > * >(argp1);
      arg1 = const_cast< FixedRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedRateCoupon > * >(argp1);
      arg1 = const_cast< FixedRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedRateCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FixedRateCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedRateCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_fixed_rate_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FixedRateCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_fixed_rate_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_fixed_rate_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateCoupon > *smartresult = result ? new ext::shared_ptr<  FixedRateCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCouponPricer_swapletPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCouponPricer_swapletPrice" "', argument " "1"" of type '" "FloatingRateCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((FloatingRateCouponPricer const *)arg1)->swapletPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCouponPricer_swapletRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCouponPricer_swapletRate" "', argument " "1"" of type '" "FloatingRateCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((FloatingRateCouponPricer const *)arg1)->swapletRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCouponPricer_capletPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatingRateCouponPricer_capletPrice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCouponPricer_capletPrice" "', argument " "1"" of type '" "FloatingRateCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatingRateCouponPricer_capletPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((FloatingRateCouponPricer const *)arg1)->capletPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCouponPricer_capletRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatingRateCouponPricer_capletRate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCouponPricer_capletRate" "', argument " "1"" of type '" "FloatingRateCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatingRateCouponPricer_capletRate" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Rate)((FloatingRateCouponPricer const *)arg1)->capletRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCouponPricer_floorletPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatingRateCouponPricer_floorletPrice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCouponPricer_floorletPrice" "', argument " "1"" of type '" "FloatingRateCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatingRateCouponPricer_floorletPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((FloatingRateCouponPricer const *)arg1)->floorletPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCouponPricer_floorletRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer const > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatingRateCouponPricer_floorletRate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCouponPricer_floorletRate" "', argument " "1"" of type '" "FloatingRateCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatingRateCouponPricer_floorletRate" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Rate)((FloatingRateCouponPricer const *)arg1)->floorletRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FloatingRateCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCouponPricer *arg1 = (FloatingRateCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempshared1 ;
  ext::shared_ptr< FloatingRateCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatingRateCouponPricer" "', argument " "1"" of type '" "FloatingRateCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatingRateCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatingRateCouponPricer > * >(argp1);
      arg1 = const_cast< FloatingRateCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloatingRateCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_setCouponPricer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setCouponPricer" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setCouponPricer" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setCouponPricer" "', argument " "2"" of type '" "ext::shared_ptr< FloatingRateCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      setCouponPricer((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< FloatingRateCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_fixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_fixingDate" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FloatingRateCoupon const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_fixingDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_fixingDays" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Integer)((FloatingRateCoupon const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_isInArrears(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_isInArrears" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((FloatingRateCoupon const *)arg1)->isInArrears();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_gearing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_gearing" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((FloatingRateCoupon const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_spread" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_indexFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_indexFixing" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_adjustedFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_adjustedFixing" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->adjustedFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_convexityAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_convexityAdjustment" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((FloatingRateCoupon const *)arg1)->convexityAdjustment();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_price(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatingRateCoupon_price", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_price" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatingRateCoupon_price" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatingRateCoupon_price" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Real)((FloatingRateCoupon const *)arg1)->price((Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon const > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< InterestRateIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_index" "', argument " "1"" of type '" "FloatingRateCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FloatingRateCoupon const *)arg1)->index();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterestRateIndex > *smartresult = result ? new ext::shared_ptr<  InterestRateIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingRateCoupon_setPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatingRateCoupon_setPricer", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingRateCoupon_setPricer" "', argument " "1"" of type '" "FloatingRateCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatingRateCoupon_setPricer" "', argument " "2"" of type '" "ext::shared_ptr< FloatingRateCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setPricer((ext::shared_ptr< FloatingRateCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FloatingRateCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateCoupon *arg1 = (FloatingRateCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon > tempshared1 ;
  ext::shared_ptr< FloatingRateCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatingRateCoupon" "', argument " "1"" of type '" "FloatingRateCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatingRateCoupon > * >(argp1);
      arg1 = const_cast< FloatingRateCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloatingRateCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_as_floating_rate_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FloatingRateCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_floating_rate_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_floating_rate_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatingRateCoupon > *smartresult = result ? new ext::shared_ptr<  FloatingRateCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateAveraging(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateAveraging *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RateAveraging", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (RateAveraging *)new RateAveraging();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RateAveraging, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RateAveraging(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateAveraging *arg1 = (RateAveraging *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RateAveraging, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RateAveraging" "', argument " "1"" of type '" "RateAveraging *""'"); 
  }
  arg1 = reinterpret_cast< RateAveraging * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RateAveraging_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RateAveraging, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RateAveraging_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  bool arg11 ;
  RateAveraging::Type arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedCoupon" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedCoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedCoupon" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_OvernightIndexedCoupon" "', argument " "12"" of type '" "RateAveraging::Type""'");
  } 
  arg12 = static_cast< RateAveraging::Type >(val12);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9,(DayCounter const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedCoupon" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedCoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedCoupon" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9,(DayCounter const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedCoupon" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedCoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9,(DayCounter const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedCoupon" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  Date *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedCoupon" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  Spread arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedCoupon" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedCoupon" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  OvernightIndexedCoupon *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedCoupon" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (OvernightIndexedCoupon *)new OvernightIndexedCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedCoupon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexedCoupon", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_OvernightIndexedCoupon__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_OvernightIndexedCoupon__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_OvernightIndexedCoupon__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_OvernightIndexedCoupon__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_OvernightIndexedCoupon__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_OvernightIndexedCoupon__SWIG_2(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_OvernightIndexedCoupon__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_OvernightIndexedCoupon__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIndexedCoupon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real,Spread,Date const &,Date const &,DayCounter const &,bool,RateAveraging::Type)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real,Spread,Date const &,Date const &,DayCounter const &,bool)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real,Spread,Date const &,Date const &,DayCounter const &)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real,Spread,Date const &,Date const &)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real,Spread,Date const &)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real,Spread)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Real)\n"
    "    OvernightIndexedCoupon::OvernightIndexedCoupon(Date const &,Real,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedCoupon_fixingDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedCoupon_fixingDates" "', argument " "1"" of type '" "OvernightIndexedCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((OvernightIndexedCoupon const *)arg1)->fixingDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedCoupon_dt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedCoupon_dt" "', argument " "1"" of type '" "OvernightIndexedCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((OvernightIndexedCoupon const *)arg1)->dt();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedCoupon_indexFixings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedCoupon_indexFixings" "', argument " "1"" of type '" "OvernightIndexedCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((OvernightIndexedCoupon const *)arg1)->indexFixings();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedCoupon_valueDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedCoupon const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedCoupon_valueDates" "', argument " "1"" of type '" "OvernightIndexedCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((OvernightIndexedCoupon const *)arg1)->valueDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIndexedCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedCoupon *arg1 = (OvernightIndexedCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedCoupon > tempshared1 ;
  ext::shared_ptr< OvernightIndexedCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndexedCoupon" "', argument " "1"" of type '" "OvernightIndexedCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedCoupon > * >(argp1);
      arg1 = const_cast< OvernightIndexedCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIndexedCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIndexedCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_overnight_indexed_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndexedCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_overnight_indexed_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_overnight_indexed_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedCoupon > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FloatingRateCoupon > *arg1 = 0 ;
  Rate arg2 = (Rate) Null< Rate >() ;
  Rate arg3 = (Rate) Null< Rate >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateCoupon > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"underlying",  (char *)"cap",  (char *)"floor",  NULL 
  };
  CappedFlooredCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_CappedFlooredCoupon", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCoupon_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCoupon" "', argument " "1"" of type '" "ext::shared_ptr< FloatingRateCoupon > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FloatingRateCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FloatingRateCoupon > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FloatingRateCoupon > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_double(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCoupon" "', argument " "2"" of type '" "Rate""'");
    } 
    arg2 = static_cast< Rate >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_double(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CappedFlooredCoupon" "', argument " "3"" of type '" "Rate""'");
    } 
    arg3 = static_cast< Rate >(val3);
  }
  {
    try {
      result = (CappedFlooredCoupon *)new CappedFlooredCoupon((ext::shared_ptr< FloatingRateCoupon > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_cap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_cap" "', argument " "1"" of type '" "CappedFlooredCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->cap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_floor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_floor" "', argument " "1"" of type '" "CappedFlooredCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->floor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_effectiveCap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_effectiveCap" "', argument " "1"" of type '" "CappedFlooredCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->effectiveCap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_effectiveFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_effectiveFloor" "', argument " "1"" of type '" "CappedFlooredCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredCoupon const *)arg1)->effectiveFloor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_isCapped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_isCapped" "', argument " "1"" of type '" "CappedFlooredCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CappedFlooredCoupon const *)arg1)->isCapped();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_isFloored(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_isFloored" "', argument " "1"" of type '" "CappedFlooredCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CappedFlooredCoupon const *)arg1)->isFloored();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredCoupon_setPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FloatingRateCouponPricer > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CappedFlooredCoupon_setPricer", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredCoupon_setPricer" "', argument " "1"" of type '" "CappedFlooredCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CappedFlooredCoupon_setPricer" "', argument " "2"" of type '" "ext::shared_ptr< FloatingRateCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FloatingRateCouponPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setPricer((ext::shared_ptr< FloatingRateCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CappedFlooredCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCoupon *arg1 = (CappedFlooredCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCoupon > tempshared1 ;
  ext::shared_ptr< CappedFlooredCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CappedFlooredCoupon" "', argument " "1"" of type '" "CappedFlooredCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CappedFlooredCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CappedFlooredCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CappedFlooredCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CappedFlooredCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IborCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 = (Real) 1.0 ;
  Spread arg8 = (Spread) 0.0 ;
  Date const &arg9_defvalue = Date() ;
  Date *arg9 = (Date *) &arg9_defvalue ;
  Date const &arg10_defvalue = Date() ;
  Date *arg10 = (Date *) &arg10_defvalue ;
  DayCounter const &arg11_defvalue = DayCounter() ;
  DayCounter *arg11 = (DayCounter *) &arg11_defvalue ;
  bool arg12 = (bool) false ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool 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 ;
  char * kwnames[] = {
    (char *)"paymentDate",  (char *)"nominal",  (char *)"startDate",  (char *)"endDate",  (char *)"fixingDays",  (char *)"index",  (char *)"gearing",  (char *)"spread",  (char *)"refPeriodStart",  (char *)"refPeriodEnd",  (char *)"dayCounter",  (char *)"isInArrears",  (char *)"exCouponDate",  NULL 
  };
  IborCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOOO:new_IborCoupon", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IborCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IborCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IborCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IborCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IborCoupon" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(obj5, &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_IborCoupon" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_IborCoupon" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_IborCoupon" "', argument " "8"" of type '" "Spread""'");
    } 
    arg8 = static_cast< Spread >(val8);
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_IborCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    arg9 = reinterpret_cast< Date * >(argp9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_IborCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    arg10 = reinterpret_cast< Date * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_IborCoupon" "', argument " "11"" of type '" "DayCounter const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "11"" of type '" "DayCounter const &""'"); 
    }
    arg11 = reinterpret_cast< DayCounter * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_IborCoupon" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_IborCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  {
    try {
      result = (IborCoupon *)new IborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborCoupon > *smartresult = result ? new ext::shared_ptr<  IborCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCoupon_createAtParCoupons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "IborCoupon_createAtParCoupons", 0, 0, 0)) SWIG_fail;
  {
    try {
      IborCoupon_createAtParCoupons();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCoupon_createIndexedCoupons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "IborCoupon_createIndexedCoupons", 0, 0, 0)) SWIG_fail;
  {
    try {
      IborCoupon_createIndexedCoupons();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCoupon_usingAtParCoupons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "IborCoupon_usingAtParCoupons", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)IborCoupon_usingAtParCoupons();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IborCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborCoupon *arg1 = (IborCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborCoupon > tempshared1 ;
  ext::shared_ptr< IborCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IborCoupon" "', argument " "1"" of type '" "IborCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IborCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IborCoupon > * >(argp1);
      arg1 = const_cast< IborCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IborCoupon > * >(argp1);
      arg1 = const_cast< IborCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IborCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IborCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IborCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CappedFlooredIborCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 = (Real) 1.0 ;
  Spread arg8 = (Spread) 0.0 ;
  Rate arg9 = (Rate) (Rate)Null< Rate >() ;
  Rate arg10 = (Rate) (Rate)Null< Rate >() ;
  Date const &arg11_defvalue = Date() ;
  Date *arg11 = (Date *) &arg11_defvalue ;
  Date const &arg12_defvalue = Date() ;
  Date *arg12 = (Date *) &arg12_defvalue ;
  DayCounter const &arg13_defvalue = DayCounter() ;
  DayCounter *arg13 = (DayCounter *) &arg13_defvalue ;
  bool arg14 = (bool) false ;
  Date const &arg15_defvalue = Date() ;
  Date *arg15 = (Date *) &arg15_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool 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 ;
  char * kwnames[] = {
    (char *)"paymentDate",  (char *)"nominal",  (char *)"startDate",  (char *)"endDate",  (char *)"fixingDays",  (char *)"index",  (char *)"gearing",  (char *)"spread",  (char *)"cap",  (char *)"floor",  (char *)"refPeriodStart",  (char *)"refPeriodEnd",  (char *)"dayCounter",  (char *)"isInArrears",  (char *)"exCouponDate",  NULL 
  };
  CappedFlooredIborCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOOOOO:new_CappedFlooredIborCoupon", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredIborCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredIborCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredIborCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredIborCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredIborCoupon" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(obj5, &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredIborCoupon" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredIborCoupon" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredIborCoupon" "', argument " "8"" of type '" "Spread""'");
    } 
    arg8 = static_cast< Spread >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_double(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredIborCoupon" "', argument " "9"" of type '" "Rate""'");
    } 
    arg9 = static_cast< Rate >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_double(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredIborCoupon" "', argument " "10"" of type '" "Rate""'");
    } 
    arg10 = static_cast< Rate >(val10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredIborCoupon" "', argument " "11"" of type '" "Date const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "11"" of type '" "Date const &""'"); 
    }
    arg11 = reinterpret_cast< Date * >(argp11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredIborCoupon" "', argument " "12"" of type '" "Date const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "12"" of type '" "Date const &""'"); 
    }
    arg12 = reinterpret_cast< Date * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredIborCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
    }
    arg13 = reinterpret_cast< DayCounter * >(argp13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_bool(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CappedFlooredIborCoupon" "', argument " "14"" of type '" "bool""'");
    } 
    arg14 = static_cast< bool >(val14);
  }
  if (obj14) {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CappedFlooredIborCoupon" "', argument " "15"" of type '" "Date const &""'"); 
    }
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredIborCoupon" "', argument " "15"" of type '" "Date const &""'"); 
    }
    arg15 = reinterpret_cast< Date * >(argp15);
  }
  {
    try {
      result = (CappedFlooredIborCoupon *)new CappedFlooredIborCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredIborCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredIborCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredIborCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CappedFlooredIborCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredIborCoupon *arg1 = (CappedFlooredIborCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredIborCoupon > tempshared1 ;
  ext::shared_ptr< CappedFlooredIborCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredIborCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CappedFlooredIborCoupon" "', argument " "1"" of type '" "CappedFlooredIborCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CappedFlooredIborCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CappedFlooredIborCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredIborCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CappedFlooredIborCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredIborCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CappedFlooredIborCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CappedFlooredIborCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CappedFlooredIborCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SubPeriodsCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Real arg7 = (Real) 1.0 ;
  Rate arg8 = (Rate) 0.0 ;
  Rate arg9 = (Rate) 0.0 ;
  Date const &arg10_defvalue = Date() ;
  Date *arg10 = (Date *) &arg10_defvalue ;
  Date const &arg11_defvalue = Date() ;
  Date *arg11 = (Date *) &arg11_defvalue ;
  DayCounter const &arg12_defvalue = DayCounter() ;
  DayCounter *arg12 = (DayCounter *) &arg12_defvalue ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"paymentDate",  (char *)"nominal",  (char *)"startDate",  (char *)"endDate",  (char *)"fixingDays",  (char *)"index",  (char *)"gearing",  (char *)"couponSpread",  (char *)"rateSpread",  (char *)"refPeriodStart",  (char *)"refPeriodEnd",  (char *)"dayCounter",  (char *)"exCouponDate",  NULL 
  };
  SubPeriodsCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOOO:new_SubPeriodsCoupon", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SubPeriodsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SubPeriodsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SubPeriodsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SubPeriodsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SubPeriodsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(obj5, &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SubPeriodsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SubPeriodsCoupon" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SubPeriodsCoupon" "', argument " "8"" of type '" "Rate""'");
    } 
    arg8 = static_cast< Rate >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_double(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SubPeriodsCoupon" "', argument " "9"" of type '" "Rate""'");
    } 
    arg9 = static_cast< Rate >(val9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SubPeriodsCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    arg10 = reinterpret_cast< Date * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_SubPeriodsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
    }
    arg11 = reinterpret_cast< Date * >(argp11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_SubPeriodsCoupon" "', argument " "12"" of type '" "DayCounter const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "12"" of type '" "DayCounter const &""'"); 
    }
    arg12 = reinterpret_cast< DayCounter * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SubPeriodsCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubPeriodsCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  {
    try {
      result = (SubPeriodsCoupon *)new SubPeriodsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(DayCounter const &)*arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SubPeriodsCoupon > *smartresult = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubPeriodsCoupon_fixingDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > tempshared1 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubPeriodsCoupon_fixingDates" "', argument " "1"" of type '" "SubPeriodsCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((SubPeriodsCoupon const *)arg1)->fixingDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubPeriodsCoupon_dt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > tempshared1 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubPeriodsCoupon_dt" "', argument " "1"" of type '" "SubPeriodsCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((SubPeriodsCoupon const *)arg1)->dt();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubPeriodsCoupon_valueDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > tempshared1 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubPeriodsCoupon_valueDates" "', argument " "1"" of type '" "SubPeriodsCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((SubPeriodsCoupon const *)arg1)->valueDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubPeriodsCoupon_rateSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SubPeriodsCoupon const > tempshared1 ;
  ext::shared_ptr< SubPeriodsCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubPeriodsCoupon_rateSpread" "', argument " "1"" of type '" "SubPeriodsCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)((SubPeriodsCoupon const *)arg1)->rateSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SubPeriodsCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SubPeriodsCoupon *arg1 = (SubPeriodsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SubPeriodsCoupon > tempshared1 ;
  ext::shared_ptr< SubPeriodsCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubPeriodsCoupon" "', argument " "1"" of type '" "SubPeriodsCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SubPeriodsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SubPeriodsCoupon > * >(argp1);
      arg1 = const_cast< SubPeriodsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SubPeriodsCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SubPeriodsCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_sub_periods_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SubPeriodsCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_sub_periods_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_sub_periods_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SubPeriodsCoupon > *smartresult = result ? new ext::shared_ptr<  SubPeriodsCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SubPeriodsCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCouponPricer_capletVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborCouponPricer const > tempshared1 ;
  ext::shared_ptr< IborCouponPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< OptionletVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborCouponPricer_capletVolatility" "', argument " "1"" of type '" "IborCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const IborCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((IborCouponPricer const *)arg1)->capletVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< OptionletVolatilityStructure >(result)), SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCouponPricer_setCapletVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborCouponPricer > tempshared1 ;
  ext::shared_ptr< IborCouponPricer > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborCouponPricer_setCapletVolatility" "', argument " "1"" of type '" "IborCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IborCouponPricer_setCapletVolatility" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborCouponPricer_setCapletVolatility" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp2);
  {
    try {
      (arg1)->setCapletVolatility((Handle< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCouponPricer_setCapletVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborCouponPricer > tempshared1 ;
  ext::shared_ptr< IborCouponPricer > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborCouponPricer_setCapletVolatility" "', argument " "1"" of type '" "IborCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->setCapletVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborCouponPricer_setCapletVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IborCouponPricer_setCapletVolatility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IborCouponPricer_setCapletVolatility__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IborCouponPricer_setCapletVolatility__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IborCouponPricer_setCapletVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IborCouponPricer::setCapletVolatility(Handle< OptionletVolatilityStructure > const &)\n"
    "    IborCouponPricer::setCapletVolatility()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IborCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborCouponPricer *arg1 = (IborCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborCouponPricer > tempshared1 ;
  ext::shared_ptr< IborCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IborCouponPricer" "', argument " "1"" of type '" "IborCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IborCouponPricer > * >(argp1);
      arg1 = const_cast< IborCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IborCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IborCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BlackIborCouponPricer(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Handle< OptionletVolatilityStructure > const &arg1_defvalue = Handle< OptionletVolatilityStructure >() ;
  Handle< OptionletVolatilityStructure > *arg1 = (Handle< OptionletVolatilityStructure > *) &arg1_defvalue ;
  BlackIborCouponPricer::TimingAdjustment arg2 = (BlackIborCouponPricer::TimingAdjustment) (BlackIborCouponPricer::TimingAdjustment)BlackIborCouponPricer::Black76 ;
  Handle< Quote > arg3 = (Handle< Quote >) (Handle< Quote >)Handle< Quote >(ext::shared_ptr<Quote>(new SimpleQuote(1.0))) ;
  ext::optional< bool > arg4 = (ext::optional< bool >) ext::nullopt ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"v",  (char *)"timingAdjustment",  (char *)"correlation",  (char *)"useIndexedCoupon",  NULL 
  };
  BlackIborCouponPricer *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:new_BlackIborCouponPricer", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  if (obj0) {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackIborCouponPricer" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackIborCouponPricer" "', argument " "1"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
    }
    arg1 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackIborCouponPricer" "', argument " "2"" of type '" "BlackIborCouponPricer::TimingAdjustment""'");
    } 
    arg2 = static_cast< BlackIborCouponPricer::TimingAdjustment >(val2);
  }
  if (obj2) {
    {
      res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackIborCouponPricer" "', argument " "3"" of type '" "Handle< Quote > const""'"); 
      }  
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackIborCouponPricer" "', argument " "3"" of type '" "Handle< Quote > const""'");
      } else {
        Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp3);
        arg3 = *temp;
        if (SWIG_IsNewObj(res3)) delete temp;
      }
    }
  }
  if (obj3) {
    if(obj3 == Py_None)
    arg4 = ext::nullopt;
    else if (obj3 == Py_True)
    arg4 = true;
    else
    arg4 = false;
    
  }
  {
    try {
      result = (BlackIborCouponPricer *)new BlackIborCouponPricer((Handle< OptionletVolatilityStructure > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackIborCouponPricer > *smartresult = result ? new ext::shared_ptr<  BlackIborCouponPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackIborCouponPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackIborCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackIborCouponPricer *arg1 = (BlackIborCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackIborCouponPricer > tempshared1 ;
  ext::shared_ptr< BlackIborCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackIborCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackIborCouponPricer" "', argument " "1"" of type '" "BlackIborCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackIborCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackIborCouponPricer > * >(argp1);
      arg1 = const_cast< BlackIborCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackIborCouponPricer > * >(argp1);
      arg1 = const_cast< BlackIborCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackIborCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackIborCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackIborCouponPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_SubPeriodsPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SubPeriodsPricer *arg1 = (SubPeriodsPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SubPeriodsPricer > tempshared1 ;
  ext::shared_ptr< SubPeriodsPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SubPeriodsPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubPeriodsPricer" "', argument " "1"" of type '" "SubPeriodsPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SubPeriodsPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SubPeriodsPricer > * >(argp1);
      arg1 = const_cast< SubPeriodsPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SubPeriodsPricer > * >(argp1);
      arg1 = const_cast< SubPeriodsPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SubPeriodsPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SubPeriodsPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CompoundingRatePricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompoundingRatePricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CompoundingRatePricer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (CompoundingRatePricer *)new CompoundingRatePricer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompoundingRatePricer > *smartresult = result ? new ext::shared_ptr<  CompoundingRatePricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompoundingRatePricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CompoundingRatePricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompoundingRatePricer *arg1 = (CompoundingRatePricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompoundingRatePricer > tempshared1 ;
  ext::shared_ptr< CompoundingRatePricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompoundingRatePricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompoundingRatePricer" "', argument " "1"" of type '" "CompoundingRatePricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompoundingRatePricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompoundingRatePricer > * >(argp1);
      arg1 = const_cast< CompoundingRatePricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompoundingRatePricer > * >(argp1);
      arg1 = const_cast< CompoundingRatePricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompoundingRatePricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CompoundingRatePricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompoundingRatePricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AveragingRatePricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AveragingRatePricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AveragingRatePricer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (AveragingRatePricer *)new AveragingRatePricer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AveragingRatePricer > *smartresult = result ? new ext::shared_ptr<  AveragingRatePricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AveragingRatePricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AveragingRatePricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AveragingRatePricer *arg1 = (AveragingRatePricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AveragingRatePricer > tempshared1 ;
  ext::shared_ptr< AveragingRatePricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AveragingRatePricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AveragingRatePricer" "', argument " "1"" of type '" "AveragingRatePricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AveragingRatePricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AveragingRatePricer > * >(argp1);
      arg1 = const_cast< AveragingRatePricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AveragingRatePricer > * >(argp1);
      arg1 = const_cast< AveragingRatePricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AveragingRatePricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AveragingRatePricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AveragingRatePricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CmsCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 = (Real) 1.0 ;
  Spread arg8 = (Spread) 0.0 ;
  Date const &arg9_defvalue = Date() ;
  Date *arg9 = (Date *) &arg9_defvalue ;
  Date const &arg10_defvalue = Date() ;
  Date *arg10 = (Date *) &arg10_defvalue ;
  DayCounter const &arg11_defvalue = DayCounter() ;
  DayCounter *arg11 = (DayCounter *) &arg11_defvalue ;
  bool arg12 = (bool) false ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool 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 ;
  char * kwnames[] = {
    (char *)"paymentDate",  (char *)"nominal",  (char *)"startDate",  (char *)"endDate",  (char *)"fixingDays",  (char *)"index",  (char *)"gearing",  (char *)"spread",  (char *)"refPeriodStart",  (char *)"refPeriodEnd",  (char *)"dayCounter",  (char *)"isInArrears",  (char *)"exCouponDate",  NULL 
  };
  CmsCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOOO:new_CmsCoupon", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CmsCoupon" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(obj5, &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CmsCoupon" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CmsCoupon" "', argument " "8"" of type '" "Spread""'");
    } 
    arg8 = static_cast< Spread >(val8);
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CmsCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    arg9 = reinterpret_cast< Date * >(argp9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CmsCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    arg10 = reinterpret_cast< Date * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CmsCoupon" "', argument " "11"" of type '" "DayCounter const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "11"" of type '" "DayCounter const &""'"); 
    }
    arg11 = reinterpret_cast< DayCounter * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CmsCoupon" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CmsCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  {
    try {
      result = (CmsCoupon *)new CmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsCoupon > *smartresult = result ? new ext::shared_ptr<  CmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsCoupon *arg1 = (CmsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCoupon > tempshared1 ;
  ext::shared_ptr< CmsCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsCoupon" "', argument " "1"" of type '" "CmsCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsCoupon > * >(argp1);
      arg1 = const_cast< CmsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsCoupon > * >(argp1);
      arg1 = const_cast< CmsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CmsCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CmsCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CmsSpreadCoupon(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 = (Real) 1.0 ;
  Spread arg8 = (Spread) 0.0 ;
  Date const &arg9_defvalue = Date() ;
  Date *arg9 = (Date *) &arg9_defvalue ;
  Date const &arg10_defvalue = Date() ;
  Date *arg10 = (Date *) &arg10_defvalue ;
  DayCounter const &arg11_defvalue = DayCounter() ;
  DayCounter *arg11 = (DayCounter *) &arg11_defvalue ;
  bool arg12 = (bool) false ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool 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 ;
  char * kwnames[] = {
    (char *)"paymentDate",  (char *)"nominal",  (char *)"startDate",  (char *)"endDate",  (char *)"fixingDays",  (char *)"index",  (char *)"gearing",  (char *)"spread",  (char *)"refPeriodStart",  (char *)"refPeriodEnd",  (char *)"dayCounter",  (char *)"isInArrears",  (char *)"exCouponDate",  NULL 
  };
  CmsSpreadCoupon *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOOO:new_CmsSpreadCoupon", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(obj5, &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
    } 
    arg8 = static_cast< Spread >(val8);
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CmsSpreadCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "9"" of type '" "Date const &""'"); 
    }
    arg9 = reinterpret_cast< Date * >(argp9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CmsSpreadCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "10"" of type '" "Date const &""'"); 
    }
    arg10 = reinterpret_cast< Date * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CmsSpreadCoupon" "', argument " "11"" of type '" "DayCounter const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "11"" of type '" "DayCounter const &""'"); 
    }
    arg11 = reinterpret_cast< DayCounter * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CmsSpreadCoupon" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CmsSpreadCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsSpreadCoupon" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  {
    try {
      result = (CmsSpreadCoupon *)new CmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,(Date const &)*arg9,(Date const &)*arg10,(DayCounter const &)*arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsSpreadCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsSpreadCoupon *arg1 = (CmsSpreadCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsSpreadCoupon > tempshared1 ;
  ext::shared_ptr< CmsSpreadCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsSpreadCoupon" "', argument " "1"" of type '" "CmsSpreadCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsSpreadCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsSpreadCoupon > * >(argp1);
      arg1 = const_cast< CmsSpreadCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsSpreadCoupon > * >(argp1);
      arg1 = const_cast< CmsSpreadCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsSpreadCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CmsSpreadCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CmsCouponPricer_swaptionVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer const > tempshared1 ;
  ext::shared_ptr< CmsCouponPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< SwaptionVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricer_swaptionVolatility" "', argument " "1"" of type '" "CmsCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CmsCouponPricer const *)arg1)->swaptionVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< SwaptionVolatilityStructure >(result)), SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricer_setSwaptionVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  ext::shared_ptr< CmsCouponPricer > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricer_setSwaptionVolatility" "', argument " "1"" of type '" "CmsCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsCouponPricer_setSwaptionVolatility" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsCouponPricer_setSwaptionVolatility" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp2);
  {
    try {
      (arg1)->setSwaptionVolatility((Handle< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricer_setSwaptionVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  ext::shared_ptr< CmsCouponPricer > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricer_setSwaptionVolatility" "', argument " "1"" of type '" "CmsCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->setSwaptionVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricer_setSwaptionVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricer_setSwaptionVolatility", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CmsCouponPricer_setSwaptionVolatility__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CmsCouponPricer_setSwaptionVolatility__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricer_setSwaptionVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CmsCouponPricer::setSwaptionVolatility(Handle< SwaptionVolatilityStructure > const &)\n"
    "    CmsCouponPricer::setSwaptionVolatility()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CmsCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsCouponPricer *arg1 = (CmsCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  ext::shared_ptr< CmsCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsCouponPricer" "', argument " "1"" of type '" "CmsCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsCouponPricer > * >(argp1);
      arg1 = const_cast< CmsCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____bool__((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____len__((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CmsCouponPricerVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *ptr = (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsCouponPricerVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsCouponPricerVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CmsCouponPricerVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CmsCouponPricerVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__setslice__(std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__setslice__(std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type,std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type,std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CmsCouponPricerVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *)std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *ptr = (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsCouponPricerVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CmsCouponPricerVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CmsCouponPricerVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__delitem__(std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsCouponPricer > *smartresult = *result ? new ext::shared_ptr<  CmsCouponPricer >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CmsCouponPricerVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CmsCouponPricerVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__getitem__(std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsCouponPricerVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< CmsCouponPricer > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CmsCouponPricerVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CmsCouponPricerVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CmsCouponPricerVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > const &)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::__setitem__(std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsCouponPricer > *smartresult = result ? new ext::shared_ptr<  CmsCouponPricer >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsCouponPricerVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__append(arg1,(ext::shared_ptr< CmsCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CmsCouponPricerVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)new std::vector< ext::shared_ptr< CmsCouponPricer > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CmsCouponPricerVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *ptr = (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CmsCouponPricerVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsCouponPricerVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)new std::vector< ext::shared_ptr< CmsCouponPricer > >((std::vector< ext::shared_ptr< CmsCouponPricer > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsCouponPricerVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsCouponPricerVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< CmsCouponPricer > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< CmsCouponPricer > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CmsCouponPricerVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CmsCouponPricerVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)new std::vector< ext::shared_ptr< CmsCouponPricer > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_CmsCouponPricerVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_CmsCouponPricerVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::erase(std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::erase(std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator,std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CmsCouponPricerVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg1 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CmsCouponPricerVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CmsCouponPricerVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > > *)new std::vector< ext::shared_ptr< CmsCouponPricer > >(arg1,(std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CmsCouponPricerVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CmsCouponPricerVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CmsCouponPricerVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CmsCouponPricerVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CmsCouponPricerVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CmsCouponPricerVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CmsCouponPricerVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::vector()\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::vector(std::vector< ext::shared_ptr< CmsCouponPricer > > const &)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::vector(std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::vector(std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsCouponPricerVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *) &((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsCouponPricer > *smartresult = *result ? new ext::shared_ptr<  CmsCouponPricer >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *) &((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsCouponPricer > *smartresult = *result ? new ext::shared_ptr<  CmsCouponPricer >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsCouponPricerVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsCouponPricerVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CmsCouponPricerVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CmsCouponPricerVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::resize(std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::resize(std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsCouponPricerVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< CmsCouponPricer > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg3 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CmsCouponPricerVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CmsCouponPricerVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsCouponPricerVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CmsCouponPricer_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< CmsCouponPricer > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CmsCouponPricerVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CmsCouponPricer >,std::allocator< ext::shared_ptr< CmsCouponPricer > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CmsCouponPricerVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsCouponPricerVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::insert(std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< CmsCouponPricer > >::insert(std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator,std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type,std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CmsCouponPricerVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CmsCouponPricerVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsCouponPricerVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsCouponPricerVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CmsCouponPricer > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsCouponPricerVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CmsCouponPricer > > *arg1 = (std::vector< ext::shared_ptr< CmsCouponPricer > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsCouponPricerVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CmsCouponPricer > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CmsCouponPricer > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsCouponPricerVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CmsCouponPricer_t_std__allocatorT_ext__shared_ptrT_CmsCouponPricer_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CmsCouponPricerVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_GFunctionFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GFunctionFactory *arg1 = (GFunctionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GFunctionFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GFunctionFactory" "', argument " "1"" of type '" "GFunctionFactory *""'"); 
  }
  arg1 = reinterpret_cast< GFunctionFactory * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GFunctionFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GFunctionFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AnalyticHaganPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  AnalyticHaganPricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AnalyticHaganPricer", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticHaganPricer" "', argument " "2"" of type '" "GFunctionFactory::YieldCurveModel""'");
  } 
  arg2 = static_cast< GFunctionFactory::YieldCurveModel >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnalyticHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (AnalyticHaganPricer *)new AnalyticHaganPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHaganPricer > *smartresult = result ? new ext::shared_ptr<  AnalyticHaganPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHaganPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHaganPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHaganPricer *arg1 = (AnalyticHaganPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHaganPricer > tempshared1 ;
  ext::shared_ptr< AnalyticHaganPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHaganPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticHaganPricer" "', argument " "1"" of type '" "AnalyticHaganPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticHaganPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticHaganPricer > * >(argp1);
      arg1 = const_cast< AnalyticHaganPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticHaganPricer > * >(argp1);
      arg1 = const_cast< AnalyticHaganPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticHaganPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticHaganPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticHaganPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NumericHaganPricer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  Rate arg4 ;
  Rate arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  NumericHaganPricer *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NumericHaganPricer" "', argument " "2"" of type '" "GFunctionFactory::YieldCurveModel""'");
  } 
  arg2 = static_cast< GFunctionFactory::YieldCurveModel >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NumericHaganPricer" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NumericHaganPricer" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_NumericHaganPricer" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NumericHaganPricer > *smartresult = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericHaganPricer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  Rate arg4 ;
  Rate arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  NumericHaganPricer *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NumericHaganPricer" "', argument " "2"" of type '" "GFunctionFactory::YieldCurveModel""'");
  } 
  arg2 = static_cast< GFunctionFactory::YieldCurveModel >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NumericHaganPricer" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NumericHaganPricer" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NumericHaganPricer > *smartresult = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericHaganPricer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  NumericHaganPricer *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NumericHaganPricer" "', argument " "2"" of type '" "GFunctionFactory::YieldCurveModel""'");
  } 
  arg2 = static_cast< GFunctionFactory::YieldCurveModel >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NumericHaganPricer" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NumericHaganPricer > *smartresult = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericHaganPricer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  GFunctionFactory::YieldCurveModel arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  NumericHaganPricer *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NumericHaganPricer" "', argument " "2"" of type '" "GFunctionFactory::YieldCurveModel""'");
  } 
  arg2 = static_cast< GFunctionFactory::YieldCurveModel >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumericHaganPricer" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (NumericHaganPricer *)new NumericHaganPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NumericHaganPricer > *smartresult = result ? new ext::shared_ptr<  NumericHaganPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumericHaganPricer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NumericHaganPricer", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NumericHaganPricer__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_NumericHaganPricer__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_NumericHaganPricer__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_NumericHaganPricer__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NumericHaganPricer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NumericHaganPricer::NumericHaganPricer(Handle< SwaptionVolatilityStructure > const &,GFunctionFactory::YieldCurveModel,Handle< Quote > const &,Rate,Rate,Real)\n"
    "    NumericHaganPricer::NumericHaganPricer(Handle< SwaptionVolatilityStructure > const &,GFunctionFactory::YieldCurveModel,Handle< Quote > const &,Rate,Rate)\n"
    "    NumericHaganPricer::NumericHaganPricer(Handle< SwaptionVolatilityStructure > const &,GFunctionFactory::YieldCurveModel,Handle< Quote > const &,Rate)\n"
    "    NumericHaganPricer::NumericHaganPricer(Handle< SwaptionVolatilityStructure > const &,GFunctionFactory::YieldCurveModel,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NumericHaganPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NumericHaganPricer *arg1 = (NumericHaganPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NumericHaganPricer > tempshared1 ;
  ext::shared_ptr< NumericHaganPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NumericHaganPricer" "', argument " "1"" of type '" "NumericHaganPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NumericHaganPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NumericHaganPricer > * >(argp1);
      arg1 = const_cast< NumericHaganPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NumericHaganPricer > * >(argp1);
      arg1 = const_cast< NumericHaganPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NumericHaganPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NumericHaganPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NumericHaganPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapIndex > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared6 ;
  CappedFlooredCmsCoupon *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (CappedFlooredCmsCoupon *)new CappedFlooredCmsCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapIndex > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsCoupon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CappedFlooredCmsCoupon", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CappedFlooredCmsCoupon__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CappedFlooredCmsCoupon__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CappedFlooredCmsCoupon__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CappedFlooredCmsCoupon__SWIG_6(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_CappedFlooredCmsCoupon__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_CappedFlooredCmsCoupon__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CappedFlooredCmsCoupon__SWIG_3(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CappedFlooredCmsCoupon__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_CappedFlooredCmsCoupon__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_CappedFlooredCmsCoupon__SWIG_0(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CappedFlooredCmsCoupon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &,DayCounter const &,bool,Date const &)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &,DayCounter const &,bool)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &,DayCounter const &)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const,Rate const,Date const &)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const,Rate const)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread,Rate const)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real,Spread)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &,Real)\n"
    "    CappedFlooredCmsCoupon::CappedFlooredCmsCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CappedFlooredCmsCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCmsCoupon *arg1 = (CappedFlooredCmsCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCmsCoupon > tempshared1 ;
  ext::shared_ptr< CappedFlooredCmsCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CappedFlooredCmsCoupon" "', argument " "1"" of type '" "CappedFlooredCmsCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CappedFlooredCmsCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CappedFlooredCmsCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCmsCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CappedFlooredCmsCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCmsCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CappedFlooredCmsCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CappedFlooredCmsCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(DayCounter const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  Date *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  Rate arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  Rate arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  Spread arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< SwapSpreadIndex > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared6 ;
  CappedFlooredCmsSpreadCoupon *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredCmsSpreadCoupon" "', argument " "6"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (CappedFlooredCmsSpreadCoupon *)new CappedFlooredCmsSpreadCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< SwapSpreadIndex > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredCmsSpreadCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredCmsSpreadCoupon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CappedFlooredCmsSpreadCoupon", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_6(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_3(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_CappedFlooredCmsSpreadCoupon__SWIG_0(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CappedFlooredCmsSpreadCoupon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &,DayCounter const &,bool,Date const &)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &,DayCounter const &,bool)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &,DayCounter const &)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const,Rate const,Date const &,Date const &)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const,Rate const,Date const &)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const,Rate const)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread,Rate const)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real,Spread)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &,Real)\n"
    "    CappedFlooredCmsSpreadCoupon::CappedFlooredCmsSpreadCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< SwapSpreadIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CappedFlooredCmsSpreadCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredCmsSpreadCoupon *arg1 = (CappedFlooredCmsSpreadCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredCmsSpreadCoupon > tempshared1 ;
  ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CappedFlooredCmsSpreadCoupon" "', argument " "1"" of type '" "CappedFlooredCmsSpreadCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCmsSpreadCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CappedFlooredCmsSpreadCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredCmsSpreadCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CappedFlooredCmsSpreadCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CappedFlooredCmsSpreadCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LinearTsrPricer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  LinearTsrPricer::Settings *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  LinearTsrPricer *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearTsrPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearTsrPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearTsrPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_LinearTsrPricer__Settings,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LinearTsrPricer" "', argument " "4"" of type '" "LinearTsrPricer::Settings const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "4"" of type '" "LinearTsrPricer::Settings const &""'"); 
  }
  arg4 = reinterpret_cast< LinearTsrPricer::Settings * >(argp4);
  {
    try {
      result = (LinearTsrPricer *)new LinearTsrPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(LinearTsrPricer::Settings const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LinearTsrPricer > *smartresult = result ? new ext::shared_ptr<  LinearTsrPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LinearTsrPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearTsrPricer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  LinearTsrPricer *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearTsrPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearTsrPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LinearTsrPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (LinearTsrPricer *)new LinearTsrPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LinearTsrPricer > *smartresult = result ? new ext::shared_ptr<  LinearTsrPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LinearTsrPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearTsrPricer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< SwaptionVolatilityStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  LinearTsrPricer *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearTsrPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "1"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearTsrPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinearTsrPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (LinearTsrPricer *)new LinearTsrPricer((Handle< SwaptionVolatilityStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LinearTsrPricer > *smartresult = result ? new ext::shared_ptr<  LinearTsrPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LinearTsrPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinearTsrPricer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LinearTsrPricer", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LinearTsrPricer__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LinearTsrPricer__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_LinearTsrPricer__Settings, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LinearTsrPricer__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LinearTsrPricer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LinearTsrPricer::LinearTsrPricer(Handle< SwaptionVolatilityStructure > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,LinearTsrPricer::Settings const &)\n"
    "    LinearTsrPricer::LinearTsrPricer(Handle< SwaptionVolatilityStructure > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &)\n"
    "    LinearTsrPricer::LinearTsrPricer(Handle< SwaptionVolatilityStructure > const &,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LinearTsrPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LinearTsrPricer *arg1 = (LinearTsrPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LinearTsrPricer > tempshared1 ;
  ext::shared_ptr< LinearTsrPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LinearTsrPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearTsrPricer" "', argument " "1"" of type '" "LinearTsrPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LinearTsrPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LinearTsrPricer > * >(argp1);
      arg1 = const_cast< LinearTsrPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LinearTsrPricer > * >(argp1);
      arg1 = const_cast< LinearTsrPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LinearTsrPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LinearTsrPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LinearTsrPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LinearTsrPricerSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LinearTsrPricerSettings", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (LinearTsrPricer::Settings *)new LinearTsrPricer::Settings();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withRateBound__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withRateBound" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withRateBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearTsrPricerSettings_withRateBound" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withRateBound(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withRateBound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withRateBound" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withRateBound" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withRateBound(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withRateBound__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withRateBound" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withRateBound();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withRateBound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LinearTsrPricerSettings_withRateBound", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LinearTsrPricerSettings_withRateBound__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinearTsrPricerSettings_withRateBound__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LinearTsrPricerSettings_withRateBound__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearTsrPricerSettings_withRateBound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LinearTsrPricer::Settings::withRateBound(Real const,Real const)\n"
    "    LinearTsrPricer::Settings::withRateBound(Real const)\n"
    "    LinearTsrPricer::Settings::withRateBound()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withVegaRatio__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withVegaRatio(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withVegaRatio__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withVegaRatio();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withVegaRatio__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearTsrPricerSettings_withVegaRatio" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withVegaRatio(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withVegaRatio(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LinearTsrPricerSettings_withVegaRatio", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LinearTsrPricerSettings_withVegaRatio__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinearTsrPricerSettings_withVegaRatio__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LinearTsrPricerSettings_withVegaRatio__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearTsrPricerSettings_withVegaRatio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LinearTsrPricer::Settings::withVegaRatio(Real const)\n"
    "    LinearTsrPricer::Settings::withVegaRatio()\n"
    "    LinearTsrPricer::Settings::withVegaRatio(Real const,Real const,Real const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withPriceThreshold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withPriceThreshold(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withPriceThreshold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withPriceThreshold();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withPriceThreshold__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearTsrPricerSettings_withPriceThreshold" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withPriceThreshold(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withPriceThreshold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LinearTsrPricerSettings_withPriceThreshold", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LinearTsrPricerSettings_withPriceThreshold__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinearTsrPricerSettings_withPriceThreshold__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LinearTsrPricerSettings_withPriceThreshold__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearTsrPricerSettings_withPriceThreshold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LinearTsrPricer::Settings::withPriceThreshold(Real const)\n"
    "    LinearTsrPricer::Settings::withPriceThreshold()\n"
    "    LinearTsrPricer::Settings::withPriceThreshold(Real const,Real const,Real const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withBSStdDevs__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withBSStdDevs(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withBSStdDevs__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withBSStdDevs();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withBSStdDevs__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  LinearTsrPricer::Settings *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinearTsrPricerSettings_withBSStdDevs" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (LinearTsrPricer::Settings *) &(arg1)->withBSStdDevs(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LinearTsrPricer__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LinearTsrPricerSettings_withBSStdDevs(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LinearTsrPricerSettings_withBSStdDevs", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LinearTsrPricerSettings_withBSStdDevs__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinearTsrPricerSettings_withBSStdDevs__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LinearTsrPricer__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LinearTsrPricerSettings_withBSStdDevs__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearTsrPricerSettings_withBSStdDevs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LinearTsrPricer::Settings::withBSStdDevs(Real const)\n"
    "    LinearTsrPricer::Settings::withBSStdDevs()\n"
    "    LinearTsrPricer::Settings::withBSStdDevs(Real const,Real const,Real const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LinearTsrPricerSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LinearTsrPricer::Settings *arg1 = (LinearTsrPricer::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LinearTsrPricer__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearTsrPricerSettings" "', argument " "1"" of type '" "LinearTsrPricer::Settings *""'"); 
  }
  arg1 = reinterpret_cast< LinearTsrPricer::Settings * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LinearTsrPricerSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LinearTsrPricer__Settings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LinearTsrPricerSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CmsSpreadCouponPricer_correlation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer const > tempshared1 ;
  ext::shared_ptr< CmsSpreadCouponPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsSpreadCouponPricer_correlation" "', argument " "1"" of type '" "CmsSpreadCouponPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CmsSpreadCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CmsSpreadCouponPricer const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsSpreadCouponPricer_setCorrelation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer > tempshared1 ;
  ext::shared_ptr< CmsSpreadCouponPricer > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsSpreadCouponPricer_setCorrelation" "', argument " "1"" of type '" "CmsSpreadCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsSpreadCouponPricer_setCorrelation" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadCouponPricer_setCorrelation" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      (arg1)->setCorrelation((Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsSpreadCouponPricer_setCorrelation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer > tempshared1 ;
  ext::shared_ptr< CmsSpreadCouponPricer > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsSpreadCouponPricer_setCorrelation" "', argument " "1"" of type '" "CmsSpreadCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->setCorrelation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsSpreadCouponPricer_setCorrelation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CmsSpreadCouponPricer_setCorrelation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CmsSpreadCouponPricer_setCorrelation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CmsSpreadCouponPricer_setCorrelation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CmsSpreadCouponPricer_setCorrelation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CmsSpreadCouponPricer::setCorrelation(Handle< Quote > const &)\n"
    "    CmsSpreadCouponPricer::setCorrelation()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CmsSpreadCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsSpreadCouponPricer *arg1 = (CmsSpreadCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsSpreadCouponPricer > tempshared1 ;
  ext::shared_ptr< CmsSpreadCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsSpreadCouponPricer" "', argument " "1"" of type '" "CmsSpreadCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsSpreadCouponPricer > * >(argp1);
      arg1 = const_cast< CmsSpreadCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsSpreadCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CmsSpreadCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  ext::optional< VolatilityType > arg5 ;
  Real arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "ext::shared_ptr< CmsCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  
  if(swig_obj[4] == Py_None)
  arg5 = ext::nullopt;
  else if (PyInt_Check(swig_obj[4]))
  arg5 = (VolatilityType) PyInt_AsLong(swig_obj[4]);
  else
  arg5 = (VolatilityType) PyLong_AsLong(swig_obj[4]);
  
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LognormalCmsSpreadPricer > *smartresult = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  ext::optional< VolatilityType > arg5 ;
  Real arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "ext::shared_ptr< CmsCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  
  if(swig_obj[4] == Py_None)
  arg5 = ext::nullopt;
  else if (PyInt_Check(swig_obj[4]))
  arg5 = (VolatilityType) PyInt_AsLong(swig_obj[4]);
  else
  arg5 = (VolatilityType) PyLong_AsLong(swig_obj[4]);
  
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LognormalCmsSpreadPricer > *smartresult = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  ext::optional< VolatilityType > arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "ext::shared_ptr< CmsCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  
  if(swig_obj[4] == Py_None)
  arg5 = ext::nullopt;
  else if (PyInt_Check(swig_obj[4]))
  arg5 = (VolatilityType) PyInt_AsLong(swig_obj[4]);
  else
  arg5 = (VolatilityType) PyLong_AsLong(swig_obj[4]);
  
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LognormalCmsSpreadPricer > *smartresult = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "ext::shared_ptr< CmsCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LognormalCmsSpreadPricer > *smartresult = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "ext::shared_ptr< CmsCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LognormalCmsSpreadPricer > *smartresult = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CmsCouponPricer > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsCouponPricer > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  LognormalCmsSpreadPricer *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "ext::shared_ptr< CmsCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CmsCouponPricer > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LognormalCmsSpreadPricer" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (LognormalCmsSpreadPricer *)new LognormalCmsSpreadPricer((ext::shared_ptr< CmsCouponPricer > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LognormalCmsSpreadPricer > *smartresult = result ? new ext::shared_ptr<  LognormalCmsSpreadPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LognormalCmsSpreadPricer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LognormalCmsSpreadPricer", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LognormalCmsSpreadPricer__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LognormalCmsSpreadPricer__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LognormalCmsSpreadPricer__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              if (PyInt_Check(argv[4]) || PyLong_Check(argv[4]) || Py_None == argv[4])
              _v = 1;
              else
              _v = 0;
            }
            if (_v) {
              return _wrap_new_LognormalCmsSpreadPricer__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              if (PyInt_Check(argv[4]) || PyLong_Check(argv[4]) || Py_None == argv[4])
              _v = 1;
              else
              _v = 0;
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_LognormalCmsSpreadPricer__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CmsCouponPricer_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              if (PyInt_Check(argv[4]) || PyLong_Check(argv[4]) || Py_None == argv[4])
              _v = 1;
              else
              _v = 0;
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LognormalCmsSpreadPricer__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LognormalCmsSpreadPricer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Size const,ext::optional< VolatilityType > const,Real const,Real const)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Size const,ext::optional< VolatilityType > const,Real const)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Size const,ext::optional< VolatilityType > const)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Size const)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &)\n"
    "    LognormalCmsSpreadPricer::LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const &,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LognormalCmsSpreadPricer_swapletPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LognormalCmsSpreadPricer_swapletPrice" "', argument " "1"" of type '" "LognormalCmsSpreadPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((LognormalCmsSpreadPricer const *)arg1)->swapletPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LognormalCmsSpreadPricer_swapletRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LognormalCmsSpreadPricer_swapletRate" "', argument " "1"" of type '" "LognormalCmsSpreadPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((LognormalCmsSpreadPricer const *)arg1)->swapletRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LognormalCmsSpreadPricer_capletPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "LognormalCmsSpreadPricer_capletPrice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LognormalCmsSpreadPricer_capletPrice" "', argument " "1"" of type '" "LognormalCmsSpreadPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LognormalCmsSpreadPricer_capletPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((LognormalCmsSpreadPricer const *)arg1)->capletPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LognormalCmsSpreadPricer_capletRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "LognormalCmsSpreadPricer_capletRate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LognormalCmsSpreadPricer_capletRate" "', argument " "1"" of type '" "LognormalCmsSpreadPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LognormalCmsSpreadPricer_capletRate" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Rate)((LognormalCmsSpreadPricer const *)arg1)->capletRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LognormalCmsSpreadPricer_floorletPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "LognormalCmsSpreadPricer_floorletPrice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LognormalCmsSpreadPricer_floorletPrice" "', argument " "1"" of type '" "LognormalCmsSpreadPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LognormalCmsSpreadPricer_floorletPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Real)((LognormalCmsSpreadPricer const *)arg1)->floorletPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LognormalCmsSpreadPricer_floorletRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  Rate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "LognormalCmsSpreadPricer_floorletRate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LognormalCmsSpreadPricer_floorletRate" "', argument " "1"" of type '" "LognormalCmsSpreadPricer const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LognormalCmsSpreadPricer_floorletRate" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    try {
      result = (Rate)((LognormalCmsSpreadPricer const *)arg1)->floorletRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LognormalCmsSpreadPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LognormalCmsSpreadPricer *arg1 = (LognormalCmsSpreadPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LognormalCmsSpreadPricer > tempshared1 ;
  ext::shared_ptr< LognormalCmsSpreadPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LognormalCmsSpreadPricer" "', argument " "1"" of type '" "LognormalCmsSpreadPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LognormalCmsSpreadPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LognormalCmsSpreadPricer > * >(argp1);
      arg1 = const_cast< LognormalCmsSpreadPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LognormalCmsSpreadPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LognormalCmsSpreadPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LognormalCmsSpreadPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_EquityCashFlowPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityCashFlowPricer *arg1 = (EquityCashFlowPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > tempshared1 ;
  ext::shared_ptr< EquityCashFlowPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityCashFlowPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquityCashFlowPricer" "', argument " "1"" of type '" "EquityCashFlowPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EquityCashFlowPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EquityCashFlowPricer > * >(argp1);
      arg1 = const_cast< EquityCashFlowPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EquityCashFlowPricer > * >(argp1);
      arg1 = const_cast< EquityCashFlowPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EquityCashFlowPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EquityCashFlowPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_setCouponPricer__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setCouponPricer" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setCouponPricer" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EquityCashFlowPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setCouponPricer" "', argument " "2"" of type '" "ext::shared_ptr< EquityCashFlowPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EquityCashFlowPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EquityCashFlowPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EquityCashFlowPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      setCouponPricer((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< EquityCashFlowPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityCashFlow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< EquityIndex > arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  bool arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  EquityCashFlow *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityCashFlow" "', argument " "2"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp2);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_EquityCashFlow" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (EquityCashFlow *)new EquityCashFlow(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityCashFlow > *smartresult = result ? new ext::shared_ptr<  EquityCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityCashFlow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< EquityIndex > arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  EquityCashFlow *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityCashFlow" "', argument " "2"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp2);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityCashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (EquityCashFlow *)new EquityCashFlow(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityCashFlow > *smartresult = result ? new ext::shared_ptr<  EquityCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityCashFlow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EquityCashFlow", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_EquityCashFlow__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_EquityCashFlow__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EquityCashFlow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EquityCashFlow::EquityCashFlow(Real,ext::shared_ptr< EquityIndex >,Date const &,Date const &,Date const &,bool)\n"
    "    EquityCashFlow::EquityCashFlow(Real,ext::shared_ptr< EquityIndex >,Date const &,Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EquityCashFlow_setPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityCashFlow *arg1 = (EquityCashFlow *) 0 ;
  ext::shared_ptr< EquityCashFlowPricer > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityCashFlow > tempshared1 ;
  ext::shared_ptr< EquityCashFlow > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EquityCashFlowPricer > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "EquityCashFlow_setPricer", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityCashFlow_setPricer" "', argument " "1"" of type '" "EquityCashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EquityCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EquityCashFlow > * >(argp1);
      arg1 = const_cast< EquityCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EquityCashFlow > * >(argp1);
      arg1 = const_cast< EquityCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EquityCashFlowPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EquityCashFlow_setPricer" "', argument " "2"" of type '" "ext::shared_ptr< EquityCashFlowPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EquityCashFlowPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EquityCashFlowPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EquityCashFlowPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setPricer((ext::shared_ptr< EquityCashFlowPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EquityCashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityCashFlow *arg1 = (EquityCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityCashFlow > tempshared1 ;
  ext::shared_ptr< EquityCashFlow > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquityCashFlow" "', argument " "1"" of type '" "EquityCashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EquityCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EquityCashFlow > * >(argp1);
      arg1 = const_cast< EquityCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EquityCashFlow > * >(argp1);
      arg1 = const_cast< EquityCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EquityCashFlow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EquityCashFlow_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EquityCashFlow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EquityQuantoCashFlowPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > arg1 ;
  Handle< BlackVolTermStructure > arg2 ;
  Handle< BlackVolTermStructure > arg3 ;
  Handle< Quote > arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  EquityQuantoCashFlowPricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EquityQuantoCashFlowPricer", 4, 4, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "1"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "1"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "2"" of type '" "Handle< BlackVolTermStructure >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "2"" of type '" "Handle< BlackVolTermStructure >""'");
    } else {
      Handle< BlackVolTermStructure > * temp = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "3"" of type '" "Handle< BlackVolTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "3"" of type '" "Handle< BlackVolTermStructure >""'");
    } else {
      Handle< BlackVolTermStructure > * temp = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "4"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityQuantoCashFlowPricer" "', argument " "4"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (EquityQuantoCashFlowPricer *)new EquityQuantoCashFlowPricer(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityQuantoCashFlowPricer > *smartresult = result ? new ext::shared_ptr<  EquityQuantoCashFlowPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityQuantoCashFlowPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EquityQuantoCashFlowPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityQuantoCashFlowPricer *arg1 = (EquityQuantoCashFlowPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityQuantoCashFlowPricer > tempshared1 ;
  ext::shared_ptr< EquityQuantoCashFlowPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityQuantoCashFlowPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquityQuantoCashFlowPricer" "', argument " "1"" of type '" "EquityQuantoCashFlowPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EquityQuantoCashFlowPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EquityQuantoCashFlowPricer > * >(argp1);
      arg1 = const_cast< EquityQuantoCashFlowPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EquityQuantoCashFlowPricer > * >(argp1);
      arg1 = const_cast< EquityQuantoCashFlowPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EquityQuantoCashFlowPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EquityQuantoCashFlowPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EquityQuantoCashFlowPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FixedRateLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Schedule *arg1 = 0 ;
  DayCounter *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg4 = 0 ;
  BusinessDayConvention arg5 = (BusinessDayConvention) Following ;
  DayCounter const &arg6_defvalue = DayCounter() ;
  DayCounter *arg6 = (DayCounter *) &arg6_defvalue ;
  Period const &arg7_defvalue = Period() ;
  Period *arg7 = (Period *) &arg7_defvalue ;
  Calendar const &arg8_defvalue = Calendar() ;
  Calendar *arg8 = (Calendar *) &arg8_defvalue ;
  BusinessDayConvention arg9 = (BusinessDayConvention) Unadjusted ;
  bool arg10 = (bool) false ;
  Calendar const &arg11_defvalue = Calendar() ;
  Calendar *arg11 = (Calendar *) &arg11_defvalue ;
  Integer arg12 = (Integer) 0 ;
  Compounding arg13 = (Compounding) Simple ;
  Frequency arg14 = (Frequency) Annual ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  char * kwnames[] = {
    (char *)"schedule",  (char *)"dayCount",  (char *)"nominals",  (char *)"couponRates",  (char *)"paymentAdjustment",  (char *)"firstPeriodDayCount",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  (char *)"paymentCalendar",  (char *)"paymentLag",  (char *)"compounding",  (char *)"compoundingFrequency",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOOOOOO:FixedRateLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateLeg" "', argument " "1"" of type '" "Schedule const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "1"" of type '" "Schedule const &""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedRateLeg" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedRateLeg" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedRateLeg" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg4 = ptr;
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FixedRateLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FixedRateLeg" "', argument " "6"" of type '" "DayCounter const &""'"); 
    }
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "6"" of type '" "DayCounter const &""'"); 
    }
    arg6 = reinterpret_cast< DayCounter * >(argp6);
  }
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FixedRateLeg" "', argument " "7"" of type '" "Period const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "7"" of type '" "Period const &""'"); 
    }
    arg7 = reinterpret_cast< Period * >(argp7);
  }
  if (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "FixedRateLeg" "', argument " "8"" of type '" "Calendar const &""'"); 
    }
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "8"" of type '" "Calendar const &""'"); 
    }
    arg8 = reinterpret_cast< Calendar * >(argp8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FixedRateLeg" "', argument " "9"" of type '" "BusinessDayConvention""'");
    } 
    arg9 = static_cast< BusinessDayConvention >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_bool(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "FixedRateLeg" "', argument " "10"" of type '" "bool""'");
    } 
    arg10 = static_cast< bool >(val10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "FixedRateLeg" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRateLeg" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    arg11 = reinterpret_cast< Calendar * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "FixedRateLeg" "', argument " "12"" of type '" "Integer""'");
    } 
    arg12 = static_cast< Integer >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_int(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "FixedRateLeg" "', argument " "13"" of type '" "Compounding""'");
    } 
    arg13 = static_cast< Compounding >(val13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "FixedRateLeg" "', argument " "14"" of type '" "Frequency""'");
    } 
    arg14 = static_cast< Frequency >(val14);
  }
  {
    try {
      result = _FixedRateLeg((Schedule const &)*arg1,(DayCounter const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,(std::vector< double,std::allocator< double > > const &)*arg4,arg5,(DayCounter const &)*arg6,(Period const &)*arg7,(Calendar const &)*arg8,arg9,arg10,(Calendar const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IborLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter const &arg4_defvalue = DayCounter() ;
  DayCounter *arg4 = (DayCounter *) &arg4_defvalue ;
  BusinessDayConvention arg5 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  std::vector< Natural,std::allocator< Natural > > const &arg6_defvalue = std::vector< Natural >() ;
  std::vector< Natural,std::allocator< Natural > > *arg6 = (std::vector< Natural,std::allocator< Natural > > *) &arg6_defvalue ;
  std::vector< Real,std::allocator< Real > > const &arg7_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg7 = (std::vector< Real,std::allocator< Real > > *) &arg7_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg8_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = (std::vector< Spread,std::allocator< Spread > > *) &arg8_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg9_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = (std::vector< Rate,std::allocator< Rate > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  bool arg11 = (bool) false ;
  Period const &arg12_defvalue = Period() ;
  Period *arg12 = (Period *) &arg12_defvalue ;
  Calendar const &arg13_defvalue = Calendar() ;
  Calendar *arg13 = (Calendar *) &arg13_defvalue ;
  BusinessDayConvention arg14 = (BusinessDayConvention) Unadjusted ;
  bool arg15 = (bool) false ;
  Calendar const &arg16_defvalue = Calendar() ;
  Calendar *arg16 = (Calendar *) &arg16_defvalue ;
  Integer arg17 = (Integer) 0 ;
  ext::optional< bool > arg18 = (ext::optional< bool >) ext::nullopt ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 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 ;
  PyObject * obj17 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"isInArrears",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  (char *)"paymentCalendar",  (char *)"paymentLag",  (char *)"withIndexedCoupons",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOOOOOOOOOOO:IborLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IborLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IborLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IborLeg" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IborLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    arg4 = reinterpret_cast< DayCounter * >(argp4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IborLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    {
      std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
      res6 = swig::asptr(obj5, &ptr);
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IborLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      arg6 = ptr;
    }
  }
  if (obj6) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res7 = swig::asptr(obj6, &ptr);
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "IborLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg7 = ptr;
    }
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "IborLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "IborLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "IborLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_bool(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "IborLeg" "', argument " "11"" of type '" "bool""'");
    } 
    arg11 = static_cast< bool >(val11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "IborLeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    arg12 = reinterpret_cast< Period * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "IborLeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    arg13 = reinterpret_cast< Calendar * >(argp13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "IborLeg" "', argument " "14"" of type '" "BusinessDayConvention""'");
    } 
    arg14 = static_cast< BusinessDayConvention >(val14);
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_bool(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "IborLeg" "', argument " "15"" of type '" "bool""'");
    } 
    arg15 = static_cast< bool >(val15);
  }
  if (obj15) {
    res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "IborLeg" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    if (!argp16) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IborLeg" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    arg16 = reinterpret_cast< Calendar * >(argp16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_int(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "IborLeg" "', argument " "17"" of type '" "Integer""'");
    } 
    arg17 = static_cast< Integer >(val17);
  }
  if (obj17) {
    if(obj17 == Py_None)
    arg18 = ext::nullopt;
    else if (obj17 == Py_True)
    arg18 = true;
    else
    arg18 = false;
    
  }
  {
    try {
      result = _IborLeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg6,(std::vector< double,std::allocator< double > > const &)*arg7,(std::vector< double,std::allocator< double > > const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar const &)*arg16,arg17,SWIG_STD_MOVE(arg18));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg3 = 0 ;
  DayCounter const &arg4_defvalue = DayCounter() ;
  DayCounter *arg4 = (DayCounter *) &arg4_defvalue ;
  BusinessDayConvention arg5 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  std::vector< Real,std::allocator< Real > > const &arg6_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg6 = (std::vector< Real,std::allocator< Real > > *) &arg6_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg7_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg7 = (std::vector< Spread,std::allocator< Spread > > *) &arg7_defvalue ;
  bool arg8 = (bool) false ;
  RateAveraging::Type arg9 = (RateAveraging::Type) RateAveraging::Compound ;
  Calendar const &arg10_defvalue = Calendar() ;
  Calendar *arg10 = (Calendar *) &arg10_defvalue ;
  Integer arg11 = (Integer) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"gearings",  (char *)"spreads",  (char *)"telescopicValueDates",  (char *)"averagingMethod",  (char *)"paymentCalendar",  (char *)"paymentLag",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOOOO:OvernightLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OvernightLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OvernightLeg" "', argument " "3"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp3) : &tempshared3;
    }
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OvernightLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    arg4 = reinterpret_cast< DayCounter * >(argp4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OvernightLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res6 = swig::asptr(obj5, &ptr);
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OvernightLeg" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightLeg" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg6 = ptr;
    }
  }
  if (obj6) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res7 = swig::asptr(obj6, &ptr);
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OvernightLeg" "', argument " "7"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightLeg" "', argument " "7"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg7 = ptr;
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_bool(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "OvernightLeg" "', argument " "8"" of type '" "bool""'");
    } 
    arg8 = static_cast< bool >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "OvernightLeg" "', argument " "9"" of type '" "RateAveraging::Type""'");
    } 
    arg9 = static_cast< RateAveraging::Type >(val9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "OvernightLeg" "', argument " "10"" of type '" "Calendar const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightLeg" "', argument " "10"" of type '" "Calendar const &""'"); 
    }
    arg10 = reinterpret_cast< Calendar * >(argp10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_int(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "OvernightLeg" "', argument " "11"" of type '" "Integer""'");
    } 
    arg11 = static_cast< Integer >(val11);
  }
  {
    try {
      result = _OvernightLeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< OvernightIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< double,std::allocator< double > > const &)*arg6,(std::vector< double,std::allocator< double > > const &)*arg7,arg8,arg9,(Calendar const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter const &arg4_defvalue = DayCounter() ;
  DayCounter *arg4 = (DayCounter *) &arg4_defvalue ;
  BusinessDayConvention arg5 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  std::vector< Natural,std::allocator< Natural > > const &arg6_defvalue = std::vector< Natural >() ;
  std::vector< Natural,std::allocator< Natural > > *arg6 = (std::vector< Natural,std::allocator< Natural > > *) &arg6_defvalue ;
  std::vector< Real,std::allocator< Real > > const &arg7_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg7 = (std::vector< Real,std::allocator< Real > > *) &arg7_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg8_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = (std::vector< Spread,std::allocator< Spread > > *) &arg8_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg9_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = (std::vector< Rate,std::allocator< Rate > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  bool arg11 = (bool) false ;
  Period const &arg12_defvalue = Period() ;
  Period *arg12 = (Period *) &arg12_defvalue ;
  Calendar const &arg13_defvalue = Calendar() ;
  Calendar *arg13 = (Calendar *) &arg13_defvalue ;
  BusinessDayConvention arg14 = (BusinessDayConvention) (BusinessDayConvention)Unadjusted ;
  bool arg15 = (bool) false ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"isInArrears",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOOOOOOOO:CmsLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsLeg" "', argument " "3"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3) : &tempshared3;
    }
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    arg4 = reinterpret_cast< DayCounter * >(argp4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    {
      std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
      res6 = swig::asptr(obj5, &ptr);
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CmsLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      arg6 = ptr;
    }
  }
  if (obj6) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res7 = swig::asptr(obj6, &ptr);
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CmsLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg7 = ptr;
    }
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CmsLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CmsLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CmsLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_bool(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CmsLeg" "', argument " "11"" of type '" "bool""'");
    } 
    arg11 = static_cast< bool >(val11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "CmsLeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    arg12 = reinterpret_cast< Period * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "CmsLeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsLeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    arg13 = reinterpret_cast< Calendar * >(argp13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "CmsLeg" "', argument " "14"" of type '" "BusinessDayConvention""'");
    } 
    arg14 = static_cast< BusinessDayConvention >(val14);
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_bool(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "CmsLeg" "', argument " "15"" of type '" "bool""'");
    } 
    arg15 = static_cast< bool >(val15);
  }
  {
    try {
      result = _CmsLeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg6,(std::vector< double,std::allocator< double > > const &)*arg7,(std::vector< double,std::allocator< double > > const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsZeroLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapIndex > *arg3 = 0 ;
  DayCounter const &arg4_defvalue = DayCounter() ;
  DayCounter *arg4 = (DayCounter *) &arg4_defvalue ;
  BusinessDayConvention arg5 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  std::vector< Natural,std::allocator< Natural > > const &arg6_defvalue = std::vector< Natural >() ;
  std::vector< Natural,std::allocator< Natural > > *arg6 = (std::vector< Natural,std::allocator< Natural > > *) &arg6_defvalue ;
  std::vector< Real,std::allocator< Real > > const &arg7_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg7 = (std::vector< Real,std::allocator< Real > > *) &arg7_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg8_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = (std::vector< Spread,std::allocator< Spread > > *) &arg8_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg9_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = (std::vector< Rate,std::allocator< Rate > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  Period const &arg11_defvalue = Period() ;
  Period *arg11 = (Period *) &arg11_defvalue ;
  Calendar const &arg12_defvalue = Calendar() ;
  Calendar *arg12 = (Calendar *) &arg12_defvalue ;
  BusinessDayConvention arg13 = (BusinessDayConvention) (BusinessDayConvention)Unadjusted ;
  bool arg14 = (bool) false ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOOOOOOO:CmsZeroLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsZeroLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsZeroLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsZeroLeg" "', argument " "3"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp3) : &tempshared3;
    }
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsZeroLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    arg4 = reinterpret_cast< DayCounter * >(argp4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsZeroLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    {
      std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
      res6 = swig::asptr(obj5, &ptr);
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CmsZeroLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      arg6 = ptr;
    }
  }
  if (obj6) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res7 = swig::asptr(obj6, &ptr);
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CmsZeroLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg7 = ptr;
    }
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CmsZeroLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CmsZeroLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CmsZeroLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CmsZeroLeg" "', argument " "11"" of type '" "Period const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "11"" of type '" "Period const &""'"); 
    }
    arg11 = reinterpret_cast< Period * >(argp11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "CmsZeroLeg" "', argument " "12"" of type '" "Calendar const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsZeroLeg" "', argument " "12"" of type '" "Calendar const &""'"); 
    }
    arg12 = reinterpret_cast< Calendar * >(argp12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_int(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "CmsZeroLeg" "', argument " "13"" of type '" "BusinessDayConvention""'");
    } 
    arg13 = static_cast< BusinessDayConvention >(val13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_bool(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "CmsZeroLeg" "', argument " "14"" of type '" "bool""'");
    } 
    arg14 = static_cast< bool >(val14);
  }
  {
    try {
      result = _CmsZeroLeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg6,(std::vector< double,std::allocator< double > > const &)*arg7,(std::vector< double,std::allocator< double > > const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CmsSpreadLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > *arg3 = 0 ;
  DayCounter const &arg4_defvalue = DayCounter() ;
  DayCounter *arg4 = (DayCounter *) &arg4_defvalue ;
  BusinessDayConvention arg5 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  std::vector< Natural,std::allocator< Natural > > const &arg6_defvalue = std::vector< Natural >() ;
  std::vector< Natural,std::allocator< Natural > > *arg6 = (std::vector< Natural,std::allocator< Natural > > *) &arg6_defvalue ;
  std::vector< Real,std::allocator< Real > > const &arg7_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg7 = (std::vector< Real,std::allocator< Real > > *) &arg7_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg8_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = (std::vector< Spread,std::allocator< Spread > > *) &arg8_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg9_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = (std::vector< Rate,std::allocator< Rate > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  bool arg11 = (bool) false ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< SwapSpreadIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"isInArrears",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOOOO:CmsSpreadLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CmsSpreadLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CmsSpreadLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_SwapSpreadIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CmsSpreadLeg" "', argument " "3"" of type '" "ext::shared_ptr< SwapSpreadIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< SwapSpreadIndex > * >(argp3) : &tempshared3;
    }
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CmsSpreadLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    arg4 = reinterpret_cast< DayCounter * >(argp4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CmsSpreadLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    {
      std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
      res6 = swig::asptr(obj5, &ptr);
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CmsSpreadLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "6"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      arg6 = ptr;
    }
  }
  if (obj6) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res7 = swig::asptr(obj6, &ptr);
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CmsSpreadLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg7 = ptr;
    }
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CmsSpreadLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CmsSpreadLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CmsSpreadLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CmsSpreadLeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_bool(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CmsSpreadLeg" "', argument " "11"" of type '" "bool""'");
    } 
    arg11 = static_cast< bool >(val11);
  }
  {
    try {
      result = _CmsSpreadLeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< SwapSpreadIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg6,(std::vector< double,std::allocator< double > > const &)*arg7,(std::vector< double,std::allocator< double > > const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubPeriodsLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  DayCounter const &arg4_defvalue = DayCounter() ;
  DayCounter *arg4 = (DayCounter *) &arg4_defvalue ;
  BusinessDayConvention arg5 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  Calendar const &arg6_defvalue = Calendar() ;
  Calendar *arg6 = (Calendar *) &arg6_defvalue ;
  Integer arg7 = (Integer) 0 ;
  std::vector< Natural,std::allocator< Natural > > const &arg8_defvalue = std::vector< Natural >() ;
  std::vector< Natural,std::allocator< Natural > > *arg8 = (std::vector< Natural,std::allocator< Natural > > *) &arg8_defvalue ;
  std::vector< Real,std::allocator< Real > > const &arg9_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg9 = (std::vector< Real,std::allocator< Real > > *) &arg9_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg10_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = (std::vector< Spread,std::allocator< Spread > > *) &arg10_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg11_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg11 = (std::vector< Spread,std::allocator< Spread > > *) &arg11_defvalue ;
  Period const &arg12_defvalue = Period() ;
  Period *arg12 = (Period *) &arg12_defvalue ;
  Calendar const &arg13_defvalue = Calendar() ;
  Calendar *arg13 = (Calendar *) &arg13_defvalue ;
  BusinessDayConvention arg14 = (BusinessDayConvention) Unadjusted ;
  bool arg15 = (bool) false ;
  RateAveraging::Type arg16 = (RateAveraging::Type) RateAveraging::Compound ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"paymentCalendar",  (char *)"paymentLag",  (char *)"fixingDays",  (char *)"gearings",  (char *)"couponSpreads",  (char *)"rateSpreads",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  (char *)"averagingMethod",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOOOOOOOOOOO:SubPeriodsLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubPeriodsLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubPeriodsLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SubPeriodsLeg" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SubPeriodsLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "4"" of type '" "DayCounter const &""'"); 
    }
    arg4 = reinterpret_cast< DayCounter * >(argp4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SubPeriodsLeg" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SubPeriodsLeg" "', argument " "6"" of type '" "Calendar const &""'"); 
    }
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "6"" of type '" "Calendar const &""'"); 
    }
    arg6 = reinterpret_cast< Calendar * >(argp6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SubPeriodsLeg" "', argument " "7"" of type '" "Integer""'");
    } 
    arg7 = static_cast< Integer >(val7);
  }
  if (obj7) {
    {
      std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SubPeriodsLeg" "', argument " "8"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "8"" of type '" "std::vector< Natural,std::allocator< Natural > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SubPeriodsLeg" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SubPeriodsLeg" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res11 = swig::asptr(obj10, &ptr);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "SubPeriodsLeg" "', argument " "11"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "11"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg11 = ptr;
    }
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "SubPeriodsLeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    arg12 = reinterpret_cast< Period * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "SubPeriodsLeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubPeriodsLeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    arg13 = reinterpret_cast< Calendar * >(argp13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "SubPeriodsLeg" "', argument " "14"" of type '" "BusinessDayConvention""'");
    } 
    arg14 = static_cast< BusinessDayConvention >(val14);
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_bool(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "SubPeriodsLeg" "', argument " "15"" of type '" "bool""'");
    } 
    arg15 = static_cast< bool >(val15);
  }
  if (obj15) {
    ecode16 = SWIG_AsVal_int(obj15, &val16);
    if (!SWIG_IsOK(ecode16)) {
      SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "SubPeriodsLeg" "', argument " "16"" of type '" "RateAveraging::Type""'");
    } 
    arg16 = static_cast< RateAveraging::Type >(val16);
  }
  {
    try {
      result = _SubPeriodsLeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(DayCounter const &)*arg4,arg5,(Calendar const &)*arg6,arg7,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(std::vector< double,std::allocator< double > > const &)*arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Duration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Duration *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Duration", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Duration *)new Duration();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Duration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Duration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Duration *arg1 = (Duration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Duration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Duration" "', argument " "1"" of type '" "Duration *""'"); 
  }
  arg1 = reinterpret_cast< Duration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Duration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Duration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Duration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CashFlows_startDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_startDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_startDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = CashFlows::startDate((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_maturityDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_maturityDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = CashFlows::maturityDate((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlowDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Date result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_previousCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_previousCashFlowDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_previousCashFlowDate" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlowDate" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = CashFlows::previousCashFlowDate((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlowDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_previousCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_previousCashFlowDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = CashFlows::previousCashFlowDate((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlowDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_previousCashFlowDate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CashFlows_previousCashFlowDate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CashFlows_previousCashFlowDate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_previousCashFlowDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::previousCashFlowDate(Leg const &,bool,Date)\n"
    "    CashFlows::previousCashFlowDate(Leg const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlowDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Date result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_nextCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_nextCashFlowDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_nextCashFlowDate" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlowDate" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = CashFlows::nextCashFlowDate((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlowDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_nextCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlowDate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_nextCashFlowDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = CashFlows::nextCashFlowDate((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlowDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_nextCashFlowDate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CashFlows_nextCashFlowDate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CashFlows_nextCashFlowDate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_nextCashFlowDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::nextCashFlowDate(Leg const &,bool,Date)\n"
    "    CashFlows::nextCashFlowDate(Leg const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlowAmount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_previousCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_previousCashFlowAmount" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_previousCashFlowAmount" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlowAmount" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::previousCashFlowAmount((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlowAmount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_previousCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_previousCashFlowAmount" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Real)CashFlows::previousCashFlowAmount((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlowAmount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_previousCashFlowAmount", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CashFlows_previousCashFlowAmount__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CashFlows_previousCashFlowAmount__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_previousCashFlowAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::previousCashFlowAmount(Leg const &,bool,Date)\n"
    "    CashFlows::previousCashFlowAmount(Leg const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlowAmount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_nextCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_nextCashFlowAmount" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_nextCashFlowAmount" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlowAmount" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::nextCashFlowAmount((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlowAmount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_nextCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlowAmount" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_nextCashFlowAmount" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Real)CashFlows::nextCashFlowAmount((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlowAmount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_nextCashFlowAmount", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CashFlows_nextCashFlowAmount__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CashFlows_nextCashFlowAmount__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_nextCashFlowAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::nextCashFlowAmount(Leg const &,bool,Date)\n"
    "    CashFlows::nextCashFlowAmount(Leg const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_previousCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_previousCashFlow" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_previousCashFlow" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlow" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = CashFlows_previousCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_previousCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_previousCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_previousCashFlow" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = CashFlows_previousCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_previousCashFlow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_previousCashFlow", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CashFlows_previousCashFlow__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CashFlows_previousCashFlow__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_previousCashFlow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::previousCashFlow(Leg const &,bool,Date)\n"
    "    CashFlows::CashFlows_previousCashFlow__SWIG_0(Leg const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  Date arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_nextCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_nextCashFlow" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_nextCashFlow" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlow" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = CashFlows_nextCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  ext::shared_ptr< CashFlow > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_nextCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_nextCashFlow" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_nextCashFlow" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = CashFlows_nextCashFlow__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_nextCashFlow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_nextCashFlow", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CashFlows_nextCashFlow__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CashFlows_nextCashFlow__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_nextCashFlow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::nextCashFlow(Leg const &,bool,Date)\n"
    "    CashFlows::CashFlows_nextCashFlow__SWIG_0(Leg const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date *arg8 = 0 ;
  Date *arg9 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "Spread""'");
  } 
  arg3 = static_cast< Spread >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_npv" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_npv" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_npv" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CashFlows_npv" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,(Date const &)*arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date *arg8 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "Spread""'");
  } 
  arg3 = static_cast< Spread >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_npv" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_npv" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_npv" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "Spread""'");
  } 
  arg3 = static_cast< Spread >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_npv" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_npv" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (Real)CashFlows_npv__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows_npv__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_npv" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_npv" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_npv" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_npv" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_npv" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_npv" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_npv" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npv" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_npv" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_npv" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_npv" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (Real)CashFlows::npv((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npv(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_npv", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_npv__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_npv__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_npv__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_npv__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_npv__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_npv__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CashFlows_npv__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CashFlows_npv__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CashFlows_npv__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_npv__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_npv__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_CashFlows_npv__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_npv'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::npv(Leg const &,ext::shared_ptr< YieldTermStructure > const &,Spread,DayCounter const &,Compounding,Frequency,bool,Date const &,Date const &)\n"
    "    CashFlows::npv(Leg const &,ext::shared_ptr< YieldTermStructure > const &,Spread,DayCounter const &,Compounding,Frequency,bool,Date const &)\n"
    "    CashFlows::npv(Leg const &,ext::shared_ptr< YieldTermStructure > const &,Spread,DayCounter const &,Compounding,Frequency,bool)\n"
    "    CashFlows::npv(Leg const &,Handle< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    CashFlows::npv(Leg const &,Handle< YieldTermStructure > const &,bool,Date const &)\n"
    "    CashFlows::npv(Leg const &,Handle< YieldTermStructure > const &,bool)\n"
    "    CashFlows::npv(Leg const &,InterestRate const &,bool,Date,Date)\n"
    "    CashFlows::npv(Leg const &,InterestRate const &,bool,Date)\n"
    "    CashFlows::npv(Leg const &,InterestRate const &,bool)\n"
    "    CashFlows::npv(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date,Date)\n"
    "    CashFlows::npv(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date)\n"
    "    CashFlows::npv(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows_bps__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows_bps__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_bps" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_bps" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_bps" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_bps" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_bps" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_bps" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_bps" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_bps" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_bps" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (Real)CashFlows::bps((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_bps(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_bps", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_bps__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_bps__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_bps__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_bps__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_bps__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_bps__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_bps__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_bps__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_bps__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CashFlows_bps__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CashFlows_bps__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_bps__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_bps'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::bps(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    CashFlows::bps(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &)\n"
    "    CashFlows::bps(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool)\n"
    "    CashFlows::bps(Leg const &,Handle< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    CashFlows::bps(Leg const &,Handle< YieldTermStructure > const &,bool,Date const &)\n"
    "    CashFlows::bps(Leg const &,Handle< YieldTermStructure > const &,bool)\n"
    "    CashFlows::bps(Leg const &,InterestRate const &,bool,Date,Date)\n"
    "    CashFlows::bps(Leg const &,InterestRate const &,bool,Date)\n"
    "    CashFlows::bps(Leg const &,InterestRate const &,bool)\n"
    "    CashFlows::bps(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date,Date)\n"
    "    CashFlows::bps(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date)\n"
    "    CashFlows::bps(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  std::pair< Real,Real > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npvbps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_npvbps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = CashFlows_npvbps__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  std::pair< Real,Real > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npvbps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = CashFlows_npvbps__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::pair< Real,Real > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npvbps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = CashFlows_npvbps__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  std::pair< Real,Real > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npvbps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_npvbps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = CashFlows_npvbps__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  std::pair< Real,Real > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npvbps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = CashFlows_npvbps__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::pair< Real,Real > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_npvbps" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_npvbps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = CashFlows_npvbps__SWIG_3((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_npvbps(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_npvbps", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_npvbps__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_npvbps__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_npvbps__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_npvbps__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_npvbps__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_npvbps__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_npvbps'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::npvbps(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    CashFlows::npvbps(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &)\n"
    "    CashFlows::npvbps(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool)\n"
    "    CashFlows::npvbps(Leg const &,Handle< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    CashFlows::npvbps(Leg const &,Handle< YieldTermStructure > const &,bool,Date const &)\n"
    "    CashFlows::CashFlows_npvbps__SWIG_3(Leg const &,Handle< YieldTermStructure > const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_atmRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Real arg6 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_atmRate" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_atmRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_atmRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_atmRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_atmRate" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_atmRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_atmRate" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_atmRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_atmRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_atmRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_atmRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  Date *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_atmRate" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_atmRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_atmRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_atmRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_atmRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_atmRate" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_atmRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)CashFlows_atmRate__SWIG_0((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_atmRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_atmRate", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_atmRate__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_atmRate__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_atmRate__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CashFlows_atmRate__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_atmRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::atmRate(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &,Date const &,Real)\n"
    "    CashFlows::atmRate(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    CashFlows::atmRate(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool,Date const &)\n"
    "    CashFlows::CashFlows_atmRate__SWIG_0(Leg const &,ext::shared_ptr< YieldTermStructure > const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Real arg9 ;
  Size arg10 ;
  Rate arg11 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  Rate result;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_yieldRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_yieldRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_yieldRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_yieldRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CashFlows_yieldRate" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CashFlows_yieldRate" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CashFlows_yieldRate" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(arg10),arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Real arg9 ;
  Size arg10 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  Rate result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_yieldRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_yieldRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_yieldRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_yieldRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CashFlows_yieldRate" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CashFlows_yieldRate" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(arg10));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  Real arg9 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_yieldRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_yieldRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_yieldRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_yieldRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CashFlows_yieldRate" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_yieldRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_yieldRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_yieldRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_yieldRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_yieldRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_yieldRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_yieldRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_yieldRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_yieldRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_yieldRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_yieldRate" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_yieldRate" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_yieldRate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (Rate)CashFlows::yield((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_yieldRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_yieldRate", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CashFlows_yieldRate__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CashFlows_yieldRate__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_yieldRate__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_CashFlows_yieldRate__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_size_t(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_CashFlows_yieldRate__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_size_t(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_CashFlows_yieldRate__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_yieldRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::yield(Leg const &,Real,DayCounter const &,Compounding,Frequency,bool,Date,Date,Real,Size,Rate)\n"
    "    CashFlows::yield(Leg const &,Real,DayCounter const &,Compounding,Frequency,bool,Date,Date,Real,Size)\n"
    "    CashFlows::yield(Leg const &,Real,DayCounter const &,Compounding,Frequency,bool,Date,Date,Real)\n"
    "    CashFlows::yield(Leg const &,Real,DayCounter const &,Compounding,Frequency,bool,Date,Date)\n"
    "    CashFlows::yield(Leg const &,Real,DayCounter const &,Compounding,Frequency,bool,Date)\n"
    "    CashFlows::yield(Leg const &,Real,DayCounter const &,Compounding,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_duration__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  bool arg4 ;
  Date arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Time result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_duration" "', argument " "3"" of type '" "Duration::Type""'");
  } 
  arg3 = static_cast< Duration::Type >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_duration" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_duration" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (Time)CashFlows::duration((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4,SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_duration__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Time result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_duration" "', argument " "3"" of type '" "Duration::Type""'");
  } 
  arg3 = static_cast< Duration::Type >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_duration" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Time)CashFlows::duration((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_duration__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  int res1 = SWIG_OLDOBJ ;
  double 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 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  Time result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_duration" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_duration" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_duration" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_duration" "', argument " "6"" of type '" "Duration::Type""'");
  } 
  arg6 = static_cast< Duration::Type >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_duration" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_duration" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CashFlows_duration" "', argument " "9"" of type '" "Date""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "9"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    try {
      result = (Time)CashFlows::duration((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_duration__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  bool arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double 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 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Time result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_duration" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_duration" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_duration" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_duration" "', argument " "6"" of type '" "Duration::Type""'");
  } 
  arg6 = static_cast< Duration::Type >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_duration" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_duration" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Time)CashFlows::duration((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_duration__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  bool arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double 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 ;
  bool val7 ;
  int ecode7 = 0 ;
  Time result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_duration" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_duration" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_duration" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_duration" "', argument " "6"" of type '" "Duration::Type""'");
  } 
  arg6 = static_cast< Duration::Type >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_duration" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (Time)CashFlows::duration((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_duration(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_duration", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CashFlows_duration__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_duration__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CashFlows_duration__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_duration__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_CashFlows_duration__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_duration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::duration(Leg const &,InterestRate const &,Duration::Type,bool,Date)\n"
    "    CashFlows::duration(Leg const &,InterestRate const &,Duration::Type,bool)\n"
    "    CashFlows::duration(Leg const &,Rate,DayCounter const &,Compounding,Frequency,Duration::Type,bool,Date,Date)\n"
    "    CashFlows::duration(Leg const &,Rate,DayCounter const &,Compounding,Frequency,Duration::Type,bool,Date)\n"
    "    CashFlows::duration(Leg const &,Rate,DayCounter const &,Compounding,Frequency,Duration::Type,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_convexity" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_convexity" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_convexity" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_convexity" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_convexity" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_convexity" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_convexity" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_convexity" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_convexity" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_convexity" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_convexity" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_convexity" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (Real)CashFlows::convexity((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_convexity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_convexity", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_convexity__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_convexity__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_convexity__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CashFlows_convexity__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CashFlows_convexity__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_convexity__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_convexity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::convexity(Leg const &,InterestRate const &,bool,Date,Date)\n"
    "    CashFlows::convexity(Leg const &,InterestRate const &,bool,Date)\n"
    "    CashFlows::convexity(Leg const &,InterestRate const &,bool)\n"
    "    CashFlows::convexity(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date,Date)\n"
    "    CashFlows::convexity(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date)\n"
    "    CashFlows::convexity(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  Date arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CashFlows_basisPointValue" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  Date arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_basisPointValue" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_basisPointValue" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_basisPointValue" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_basisPointValue" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  Date arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_basisPointValue" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_basisPointValue" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CashFlows_basisPointValue" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_basisPointValue" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CashFlows_basisPointValue" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_basisPointValue" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_basisPointValue" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (Real)CashFlows::basisPointValue((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_basisPointValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_basisPointValue", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CashFlows_basisPointValue__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CashFlows_basisPointValue__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CashFlows_basisPointValue__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CashFlows_basisPointValue__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CashFlows_basisPointValue__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_basisPointValue__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_basisPointValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::basisPointValue(Leg const &,InterestRate const &,bool,Date,Date)\n"
    "    CashFlows::basisPointValue(Leg const &,InterestRate const &,bool,Date)\n"
    "    CashFlows::basisPointValue(Leg const &,InterestRate const &,bool)\n"
    "    CashFlows::basisPointValue(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date,Date)\n"
    "    CashFlows::basisPointValue(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool,Date)\n"
    "    CashFlows::basisPointValue(Leg const &,Rate,DayCounter const &,Compounding,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Size arg11 ;
  Rate arg12 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  Spread result;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_zSpread" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CashFlows_zSpread" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CashFlows_zSpread" "', argument " "11"" of type '" "Size""'");
  } 
  arg11 = static_cast< Size >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "CashFlows_zSpread" "', argument " "12"" of type '" "Rate""'");
  } 
  arg12 = static_cast< Rate >(val12);
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9),arg10,SWIG_STD_MOVE(arg11),arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  Size arg11 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  Spread result;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_zSpread" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CashFlows_zSpread" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CashFlows_zSpread" "', argument " "11"" of type '" "Size""'");
  } 
  arg11 = static_cast< Size >(val11);
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9),arg10,SWIG_STD_MOVE(arg11));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  Real arg10 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Spread result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_zSpread" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CashFlows_zSpread" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9),arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  Date arg9 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  Spread result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_zSpread" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "9"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8),SWIG_STD_MOVE(arg9));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  Date arg8 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  Spread result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_zSpread" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7,SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  bool arg7 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Spread result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CashFlows_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CashFlows_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CashFlows_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CashFlows_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CashFlows_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CashFlows_zSpread" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (Spread)CashFlows::zSpread((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CashFlows_zSpread(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CashFlows_zSpread", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CashFlows_zSpread__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_CashFlows_zSpread__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_CashFlows_zSpread__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_CashFlows_zSpread__SWIG_2(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_size_t(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_CashFlows_zSpread__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_size_t(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_CashFlows_zSpread__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CashFlows_zSpread'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CashFlows::zSpread(Leg const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,bool,Date,Date,Real,Size,Rate)\n"
    "    CashFlows::zSpread(Leg const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,bool,Date,Date,Real,Size)\n"
    "    CashFlows::zSpread(Leg const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,bool,Date,Date,Real)\n"
    "    CashFlows::zSpread(Leg const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,bool,Date,Date)\n"
    "    CashFlows::zSpread(Leg const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,bool,Date)\n"
    "    CashFlows::zSpread(Leg const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashFlows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CashFlows *arg1 = (CashFlows *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CashFlows, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashFlows" "', argument " "1"" of type '" "CashFlows *""'"); 
  }
  arg1 = reinterpret_cast< CashFlows * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashFlows_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CashFlows, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Dividend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Dividend *arg1 = (Dividend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Dividend > tempshared1 ;
  ext::shared_ptr< Dividend > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Dividend_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dividend" "', argument " "1"" of type '" "Dividend *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Dividend > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Dividend > * >(argp1);
      arg1 = const_cast< Dividend * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Dividend > * >(argp1);
      arg1 = const_cast< Dividend * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dividend_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Dividend_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FixedDividend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  FixedDividend *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FixedDividend", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FixedDividend" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedDividend" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedDividend" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (FixedDividend *)new FixedDividend(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedDividend > *smartresult = result ? new ext::shared_ptr<  FixedDividend >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedDividend_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedDividend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedDividend *arg1 = (FixedDividend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedDividend > tempshared1 ;
  ext::shared_ptr< FixedDividend > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedDividend_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedDividend" "', argument " "1"" of type '" "FixedDividend *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedDividend > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedDividend > * >(argp1);
      arg1 = const_cast< FixedDividend * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedDividend > * >(argp1);
      arg1 = const_cast< FixedDividend * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedDividend_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FixedDividend_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedDividend_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FractionalDividend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Date *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  FractionalDividend *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FractionalDividend", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FractionalDividend" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FractionalDividend" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FractionalDividend" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (FractionalDividend *)new FractionalDividend(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FractionalDividend > *smartresult = result ? new ext::shared_ptr<  FractionalDividend >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FractionalDividend_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FractionalDividend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FractionalDividend *arg1 = (FractionalDividend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FractionalDividend > tempshared1 ;
  ext::shared_ptr< FractionalDividend > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FractionalDividend_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FractionalDividend" "', argument " "1"" of type '" "FractionalDividend *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FractionalDividend > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FractionalDividend > * >(argp1);
      arg1 = const_cast< FractionalDividend * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FractionalDividend > * >(argp1);
      arg1 = const_cast< FractionalDividend * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FractionalDividend_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FractionalDividend_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FractionalDividend_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DividendSchedule_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< Dividend > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____bool__((std::vector< ext::shared_ptr< Dividend > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____len__((std::vector< ext::shared_ptr< Dividend > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DividendSchedule___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DividendSchedule___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DividendSchedule___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DividendSchedule___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DividendSchedule___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DividendSchedule___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DividendSchedule___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__setslice__(std::vector< ext::shared_ptr< Dividend > >::difference_type,std::vector< ext::shared_ptr< Dividend > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__setslice__(std::vector< ext::shared_ptr< Dividend > >::difference_type,std::vector< ext::shared_ptr< Dividend > >::difference_type,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DividendSchedule___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendSchedule___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DividendSchedule___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DividendSchedule___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DividendSchedule___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__delitem__(std::vector< ext::shared_ptr< Dividend > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Dividend > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< Dividend > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Dividend > *smartresult = *result ? new ext::shared_ptr<  Dividend >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Dividend_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Dividend > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DividendSchedule___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DividendSchedule___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__getitem__(std::vector< ext::shared_ptr< Dividend > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendSchedule___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Dividend > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DividendSchedule___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DividendSchedule___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Dividend_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DividendSchedule___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::__setitem__(std::vector< ext::shared_ptr< Dividend > >::difference_type,std::vector< ext::shared_ptr< Dividend > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Dividend > *smartresult = result ? new ext::shared_ptr<  Dividend >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Dividend_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DividendSchedule_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__append(arg1,(ext::shared_ptr< Dividend > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendSchedule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > > *)new std::vector< ext::shared_ptr< Dividend > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendSchedule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DividendSchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DividendSchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > > *)new std::vector< ext::shared_ptr< Dividend > >((std::vector< ext::shared_ptr< Dividend > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< Dividend > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Dividend > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DividendSchedule_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DividendSchedule_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< Dividend > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Dividend > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< Dividend > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Dividend_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendSchedule__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DividendSchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > > *)new std::vector< ext::shared_ptr< Dividend > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DividendSchedule_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DividendSchedule_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::erase(std::vector< ext::shared_ptr< Dividend > >::iterator)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::erase(std::vector< ext::shared_ptr< Dividend > >::iterator,std::vector< ext::shared_ptr< Dividend > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DividendSchedule__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg1 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< Dividend > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DividendSchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DividendSchedule" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > > *)new std::vector< ext::shared_ptr< Dividend > >(arg1,(std::vector< ext::shared_ptr< Dividend > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendSchedule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DividendSchedule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DividendSchedule__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DividendSchedule__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DividendSchedule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Dividend_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DividendSchedule__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DividendSchedule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::vector()\n"
    "    std::vector< ext::shared_ptr< Dividend > >::vector(std::vector< ext::shared_ptr< Dividend > > const &)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::vector(std::vector< ext::shared_ptr< Dividend > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::vector(std::vector< ext::shared_ptr< Dividend > >::size_type,std::vector< ext::shared_ptr< Dividend > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DividendSchedule_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< Dividend > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > >::value_type *) &((std::vector< ext::shared_ptr< Dividend > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Dividend > *smartresult = *result ? new ext::shared_ptr<  Dividend >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Dividend_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Dividend > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Dividend > >::value_type *) &((std::vector< ext::shared_ptr< Dividend > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Dividend > *smartresult = *result ? new ext::shared_ptr<  Dividend >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Dividend_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Dividend > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendSchedule_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< Dividend > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendSchedule_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< Dividend > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DividendSchedule_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Dividend_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DividendSchedule_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::resize(std::vector< ext::shared_ptr< Dividend > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::resize(std::vector< ext::shared_ptr< Dividend > >::size_type,std::vector< ext::shared_ptr< Dividend > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendSchedule_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Dividend > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Dividend > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg3 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< Dividend > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DividendSchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DividendSchedule_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Dividend_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DividendSchedule_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< Dividend > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Dividend_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< Dividend > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendSchedule_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Dividend_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DividendSchedule_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Dividend > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Dividend_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DividendSchedule_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendSchedule_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Dividend > >::insert(std::vector< ext::shared_ptr< Dividend > >::iterator,std::vector< ext::shared_ptr< Dividend > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< Dividend > >::insert(std::vector< ext::shared_ptr< Dividend > >::iterator,std::vector< ext::shared_ptr< Dividend > >::size_type,std::vector< ext::shared_ptr< Dividend > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  std::vector< ext::shared_ptr< Dividend > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DividendSchedule_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendSchedule_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Dividend > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Dividend > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendSchedule_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Dividend > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendSchedule_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Dividend > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DividendSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend > > *arg1 = (std::vector< ext::shared_ptr< Dividend > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DividendSchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Dividend > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DividendSchedule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Dividend_t_std__allocatorT_ext__shared_ptrT_Dividend_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DividendSchedule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Exercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise::Type arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Exercise *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Exercise" "', argument " "1"" of type '" "Exercise::Type""'");
  } 
  arg1 = static_cast< Exercise::Type >(val1);
  {
    try {
      result = (Exercise *)new Exercise(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Exercise > *smartresult = result ? new ext::shared_ptr<  Exercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Exercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise *arg1 = (Exercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise const > tempshared1 ;
  ext::shared_ptr< Exercise const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Exercise::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exercise_type" "', argument " "1"" of type '" "Exercise const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Exercise::Type)((Exercise const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_date(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise *arg1 = (Exercise *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Exercise_date", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exercise_date" "', argument " "1"" of type '" "Exercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Exercise_date" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (arg1)->date(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_dateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise *arg1 = (Exercise *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "Exercise_dateAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exercise_dateAt" "', argument " "1"" of type '" "Exercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Exercise_dateAt" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (arg1)->dateAt(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise *arg1 = (Exercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exercise_dates" "', argument " "1"" of type '" "Exercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &(arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exercise_lastDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise *arg1 = (Exercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise const > tempshared1 ;
  ext::shared_ptr< Exercise const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exercise_lastDate" "', argument " "1"" of type '" "Exercise const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Exercise const *)arg1)->lastDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Exercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Exercise *arg1 = (Exercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  ext::shared_ptr< Exercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Exercise" "', argument " "1"" of type '" "Exercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Exercise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Exercise_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Exercise_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EuropeanExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EuropeanExercise *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuropeanExercise" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EuropeanExercise" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    try {
      result = (EuropeanExercise *)new EuropeanExercise((Date const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuropeanExercise > *smartresult = result ? new ext::shared_ptr<  EuropeanExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuropeanExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EuropeanExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EuropeanExercise *arg1 = (EuropeanExercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EuropeanExercise > tempshared1 ;
  ext::shared_ptr< EuropeanExercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EuropeanExercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EuropeanExercise" "', argument " "1"" of type '" "EuropeanExercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EuropeanExercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EuropeanExercise > * >(argp1);
      arg1 = const_cast< EuropeanExercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EuropeanExercise > * >(argp1);
      arg1 = const_cast< EuropeanExercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EuropeanExercise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EuropeanExercise_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EuropeanExercise_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AmericanExercise__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  AmericanExercise *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AmericanExercise" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmericanExercise" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AmericanExercise" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmericanExercise" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AmericanExercise" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (AmericanExercise *)new AmericanExercise((Date const &)*arg1,(Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AmericanExercise > *smartresult = result ? new ext::shared_ptr<  AmericanExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AmericanExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmericanExercise__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  AmericanExercise *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AmericanExercise" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmericanExercise" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AmericanExercise" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmericanExercise" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (AmericanExercise *)new AmericanExercise((Date const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AmericanExercise > *smartresult = result ? new ext::shared_ptr<  AmericanExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AmericanExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AmericanExercise(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AmericanExercise", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AmericanExercise__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AmericanExercise__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AmericanExercise'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AmericanExercise::AmericanExercise(Date const &,Date const &,bool)\n"
    "    AmericanExercise::AmericanExercise(Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AmericanExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmericanExercise *arg1 = (AmericanExercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmericanExercise > tempshared1 ;
  ext::shared_ptr< AmericanExercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmericanExercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AmericanExercise" "', argument " "1"" of type '" "AmericanExercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AmericanExercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AmericanExercise > * >(argp1);
      arg1 = const_cast< AmericanExercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AmericanExercise > * >(argp1);
      arg1 = const_cast< AmericanExercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AmericanExercise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AmericanExercise_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AmericanExercise_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BermudanExercise__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  BermudanExercise *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BermudanExercise" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BermudanExercise" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BermudanExercise" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (BermudanExercise *)new BermudanExercise((std::vector< Date,std::allocator< Date > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BermudanExercise > *smartresult = result ? new ext::shared_ptr<  BermudanExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BermudanExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BermudanExercise__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  BermudanExercise *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BermudanExercise" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BermudanExercise" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (BermudanExercise *)new BermudanExercise((std::vector< Date,std::allocator< Date > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BermudanExercise > *smartresult = result ? new ext::shared_ptr<  BermudanExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BermudanExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BermudanExercise(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BermudanExercise", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BermudanExercise__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BermudanExercise__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BermudanExercise'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BermudanExercise::BermudanExercise(std::vector< Date,std::allocator< Date > > const &,bool)\n"
    "    BermudanExercise::BermudanExercise(std::vector< Date,std::allocator< Date > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BermudanExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BermudanExercise *arg1 = (BermudanExercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BermudanExercise > tempshared1 ;
  ext::shared_ptr< BermudanExercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BermudanExercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BermudanExercise" "', argument " "1"" of type '" "BermudanExercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BermudanExercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BermudanExercise > * >(argp1);
      arg1 = const_cast< BermudanExercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BermudanExercise > * >(argp1);
      arg1 = const_cast< BermudanExercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BermudanExercise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BermudanExercise_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BermudanExercise_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RebatedExercise__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Exercise *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise const > tempshared1 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  RebatedExercise *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      arg1 = const_cast< Exercise * >(reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_RebatedExercise" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RebatedExercise" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RebatedExercise" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RebatedExercise" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RebatedExercise" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  {
    try {
      result = (RebatedExercise *)new RebatedExercise((Exercise const &)*arg1,arg2,arg3,(Calendar const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RebatedExercise > *smartresult = result ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RebatedExercise__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Exercise *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise const > tempshared1 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  RebatedExercise *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      arg1 = const_cast< Exercise * >(reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_RebatedExercise" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RebatedExercise" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RebatedExercise" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RebatedExercise" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (RebatedExercise *)new RebatedExercise((Exercise const &)*arg1,arg2,arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RebatedExercise > *smartresult = result ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RebatedExercise__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Exercise *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Natural arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise const > tempshared1 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  RebatedExercise *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      arg1 = const_cast< Exercise * >(reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_RebatedExercise" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RebatedExercise" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    try {
      result = (RebatedExercise *)new RebatedExercise((Exercise const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RebatedExercise > *smartresult = result ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RebatedExercise__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Exercise *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise const > tempshared1 ;
  RebatedExercise *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RebatedExercise" "', argument " "1"" of type '" "Exercise const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1);
      arg1 = const_cast< Exercise * >(tempshared1.get());
    } else {
      arg1 = const_cast< Exercise * >(reinterpret_cast< ext::shared_ptr< const Exercise > * >(argp1)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_RebatedExercise" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (RebatedExercise *)new RebatedExercise((Exercise const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RebatedExercise > *smartresult = result ? new ext::shared_ptr<  RebatedExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RebatedExercise(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RebatedExercise", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RebatedExercise__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RebatedExercise__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RebatedExercise__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_RebatedExercise__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RebatedExercise'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RebatedExercise::RebatedExercise(Exercise const &,std::vector< Real,std::allocator< Real > > const,Natural,Calendar const &,BusinessDayConvention const)\n"
    "    RebatedExercise::RebatedExercise(Exercise const &,std::vector< Real,std::allocator< Real > > const,Natural,Calendar const &)\n"
    "    RebatedExercise::RebatedExercise(Exercise const &,std::vector< Real,std::allocator< Real > > const,Natural)\n"
    "    RebatedExercise::RebatedExercise(Exercise const &,std::vector< Real,std::allocator< Real > > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RebatedExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RebatedExercise *arg1 = (RebatedExercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RebatedExercise > tempshared1 ;
  ext::shared_ptr< RebatedExercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RebatedExercise" "', argument " "1"" of type '" "RebatedExercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  RebatedExercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  RebatedExercise > * >(argp1);
      arg1 = const_cast< RebatedExercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  RebatedExercise > * >(argp1);
      arg1 = const_cast< RebatedExercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RebatedExercise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_RebatedExercise_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RebatedExercise_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SwingExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  SwingExercise *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwingExercise" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwingExercise" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (SwingExercise *)new SwingExercise((std::vector< Date,std::allocator< Date > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwingExercise > *smartresult = result ? new ext::shared_ptr<  SwingExercise >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwingExercise_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwingExercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwingExercise *arg1 = (SwingExercise *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwingExercise > tempshared1 ;
  ext::shared_ptr< SwingExercise > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwingExercise_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwingExercise" "', argument " "1"" of type '" "SwingExercise *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwingExercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwingExercise > * >(argp1);
      arg1 = const_cast< SwingExercise * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwingExercise > * >(argp1);
      arg1 = const_cast< SwingExercise * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwingExercise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwingExercise_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwingExercise_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TimeGrid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TimeGrid *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (TimeGrid *)new TimeGrid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeGrid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Time arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TimeGrid *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeGrid" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeGrid" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TimeGrid *)new TimeGrid(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeGrid__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  TimeGrid *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeGrid" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeGrid" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (TimeGrid *)new_TimeGrid__SWIG_2((std::vector< double,std::allocator< double > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeGrid__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Size arg2 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  TimeGrid *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeGrid" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeGrid" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeGrid" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TimeGrid *)new_TimeGrid__SWIG_3((std::vector< double,std::allocator< double > > const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeGrid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TimeGrid", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TimeGrid__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeGrid__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TimeGrid__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TimeGrid__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TimeGrid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TimeGrid::TimeGrid()\n"
    "    TimeGrid::TimeGrid(Time,Size)\n"
    "    TimeGrid::TimeGrid(std::vector< Time,std::allocator< Time > > const &)\n"
    "    TimeGrid::TimeGrid(std::vector< Time,std::allocator< Time > > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeGrid___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeGrid *arg1 = (TimeGrid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeGrid___len__" "', argument " "1"" of type '" "TimeGrid const *""'"); 
  }
  arg1 = reinterpret_cast< TimeGrid * >(argp1);
  {
    try {
      result = ((TimeGrid const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeGrid___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeGrid *arg1 = (TimeGrid *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeGrid___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeGrid___getitem__" "', argument " "1"" of type '" "TimeGrid *""'"); 
  }
  arg1 = reinterpret_cast< TimeGrid * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeGrid___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (Time)TimeGrid___getitem__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeGrid_dt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeGrid *arg1 = (TimeGrid *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeGrid_dt", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeGrid, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeGrid_dt" "', argument " "1"" of type '" "TimeGrid const *""'"); 
  }
  arg1 = reinterpret_cast< TimeGrid * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeGrid_dt" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (Time)TimeGrid_dt((TimeGrid const *)arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TimeGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeGrid *arg1 = (TimeGrid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeGrid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeGrid" "', argument " "1"" of type '" "TimeGrid *""'"); 
  }
  arg1 = reinterpret_cast< TimeGrid * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeGrid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TimeGrid, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TimeGrid_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StochasticProcess_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_size" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((StochasticProcess const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_factors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_factors" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((StochasticProcess const *)arg1)->factors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_initialValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_initialValues" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((StochasticProcess const *)arg1)->initialValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_drift(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess_drift", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_drift" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess_drift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess_drift" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_drift" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = ((StochasticProcess const *)arg1)->drift(arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_diffusion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess_diffusion", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_diffusion" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess_diffusion" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess_diffusion" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_diffusion" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = ((StochasticProcess const *)arg1)->diffusion(arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_expectation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess_expectation", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_expectation" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess_expectation" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess_expectation" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_expectation" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess_expectation" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = ((StochasticProcess const *)arg1)->expectation(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_stdDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess_stdDeviation", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_stdDeviation" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess_stdDeviation" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess_stdDeviation" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_stdDeviation" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess_stdDeviation" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = ((StochasticProcess const *)arg1)->stdDeviation(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_covariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess_covariance", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_covariance" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess_covariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess_covariance" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_covariance" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess_covariance" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = ((StochasticProcess const *)arg1)->covariance(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess_evolve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  Time arg2 ;
  Array *arg3 = 0 ;
  Time arg4 ;
  Array *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess const > tempshared1 ;
  ext::shared_ptr< StochasticProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Array temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess_evolve", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess_evolve" "', argument " "1"" of type '" "StochasticProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess_evolve" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess_evolve" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_evolve" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess_evolve" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    if (ArrayFromSequence(swig_obj[4],&temp5)) {
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StochasticProcess_evolve" "', argument " "5"" of type '" "Array const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess_evolve" "', argument " "5"" of type '" "Array const &""'"); 
      }
      arg5 = reinterpret_cast< Array * >(argp5);
    }
  }
  {
    try {
      result = ((StochasticProcess const *)arg1)->evolve(arg2,(Array const &)*arg3,arg4,(Array const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StochasticProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess *arg1 = (StochasticProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  ext::shared_ptr< StochasticProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StochasticProcess" "', argument " "1"" of type '" "StochasticProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StochasticProcess > * >(argp1);
      arg1 = const_cast< StochasticProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StochasticProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_StochasticProcessVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____bool__((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____len__((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcessVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcessVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcessVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StochasticProcessVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcessVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StochasticProcessVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StochasticProcessVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__setslice__(std::vector< ext::shared_ptr< StochasticProcess > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__setslice__(std::vector< ext::shared_ptr< StochasticProcess > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcessVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcessVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcessVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StochasticProcessVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StochasticProcessVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__delitem__(std::vector< ext::shared_ptr< StochasticProcess > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess > *smartresult = *result ? new ext::shared_ptr<  StochasticProcess >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StochasticProcess > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StochasticProcessVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StochasticProcessVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__getitem__(std::vector< ext::shared_ptr< StochasticProcess > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcessVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< StochasticProcess > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StochasticProcessVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcessVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcessVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::__setitem__(std::vector< ext::shared_ptr< StochasticProcess > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess > *smartresult = result ? new ext::shared_ptr<  StochasticProcess >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StochasticProcessVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__append(arg1,(ext::shared_ptr< StochasticProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcessVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new std::vector< ext::shared_ptr< StochasticProcess > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcessVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StochasticProcessVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StochasticProcessVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new std::vector< ext::shared_ptr< StochasticProcess > >((std::vector< ext::shared_ptr< StochasticProcess > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StochasticProcessVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcessVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< StochasticProcess > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< StochasticProcess > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcessVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StochasticProcessVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new std::vector< ext::shared_ptr< StochasticProcess > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StochasticProcessVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StochasticProcessVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::erase(std::vector< ext::shared_ptr< StochasticProcess > >::iterator)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::erase(std::vector< ext::shared_ptr< StochasticProcess > >::iterator,std::vector< ext::shared_ptr< StochasticProcess > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcessVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg1 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< StochasticProcess > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StochasticProcessVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StochasticProcessVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > > *)new std::vector< ext::shared_ptr< StochasticProcess > >(arg1,(std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcessVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StochasticProcessVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_StochasticProcessVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StochasticProcessVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StochasticProcessVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StochasticProcessVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StochasticProcessVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::vector()\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::vector(std::vector< ext::shared_ptr< StochasticProcess > > const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::vector(std::vector< ext::shared_ptr< StochasticProcess > >::size_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::vector(std::vector< ext::shared_ptr< StochasticProcess > >::size_type,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StochasticProcessVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > >::value_type *) &((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess > *smartresult = *result ? new ext::shared_ptr<  StochasticProcess >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StochasticProcess > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess > >::value_type *) &((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess > *smartresult = *result ? new ext::shared_ptr<  StochasticProcess >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StochasticProcess > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcessVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcessVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StochasticProcessVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcessVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::resize(std::vector< ext::shared_ptr< StochasticProcess > >::size_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::resize(std::vector< ext::shared_ptr< StochasticProcess > >::size_type,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcessVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< StochasticProcess > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg3 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcessVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcessVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StochasticProcessVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< StochasticProcess > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcessVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcessVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess >,std::allocator< ext::shared_ptr< StochasticProcess > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StochasticProcessVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcessVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::insert(std::vector< ext::shared_ptr< StochasticProcess > >::iterator,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess > >::insert(std::vector< ext::shared_ptr< StochasticProcess > >::iterator,std::vector< ext::shared_ptr< StochasticProcess > >::size_type,std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcessVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcessVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcessVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcessVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StochasticProcessVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StochasticProcessVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StochasticProcessVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess_t_std__allocatorT_ext__shared_ptrT_StochasticProcess_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StochasticProcessVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StochasticProcess1D_x0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_x0" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->x0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_drift(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_drift", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_drift" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_drift" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_drift" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->drift(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_diffusion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_diffusion", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_diffusion" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_diffusion" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_diffusion" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->diffusion(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_expectation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_expectation", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_expectation" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_expectation" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_expectation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess1D_expectation" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->expectation(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_stdDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_stdDeviation", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_stdDeviation" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_stdDeviation" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_stdDeviation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess1D_stdDeviation" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->stdDeviation(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_variance", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_variance" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_variance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_variance" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess1D_variance" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->variance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_evolve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Time arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_evolve", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_evolve" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_evolve" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_evolve" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StochasticProcess1D_evolve" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StochasticProcess1D_evolve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->evolve(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1D_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D const > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1D_apply", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1D_apply" "', argument " "1"" of type '" "StochasticProcess1D const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1D_apply" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1D_apply" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((StochasticProcess1D const *)arg1)->apply(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StochasticProcess1D(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcess1D *arg1 = (StochasticProcess1D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempshared1 ;
  ext::shared_ptr< StochasticProcess1D > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StochasticProcess1D" "', argument " "1"" of type '" "StochasticProcess1D *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StochasticProcess1D > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StochasticProcess1D > * >(argp1);
      arg1 = const_cast< StochasticProcess1D * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StochasticProcess1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____bool__((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____len__((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1DVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StochasticProcess1DVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess1DVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StochasticProcess1DVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StochasticProcess1DVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__setslice__(std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__setslice__(std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1DVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *)std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess1DVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StochasticProcess1DVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StochasticProcess1DVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__delitem__(std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess1D > *smartresult = *result ? new ext::shared_ptr<  StochasticProcess1D >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StochasticProcess1DVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StochasticProcess1DVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__getitem__(std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess1DVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< StochasticProcess1D > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StochasticProcess1DVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcess1DVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcess1DVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::__setitem__(std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess1D > *smartresult = result ? new ext::shared_ptr<  StochasticProcess1D >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StochasticProcess1DVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__append(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcess1DVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)new std::vector< ext::shared_ptr< StochasticProcess1D > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcess1DVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StochasticProcess1DVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StochasticProcess1DVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)new std::vector< ext::shared_ptr< StochasticProcess1D > >((std::vector< ext::shared_ptr< StochasticProcess1D > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StochasticProcess1DVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StochasticProcess1DVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< StochasticProcess1D > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< StochasticProcess1D > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcess1DVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StochasticProcess1DVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)new std::vector< ext::shared_ptr< StochasticProcess1D > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StochasticProcess1DVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StochasticProcess1DVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::erase(std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::erase(std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator,std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcess1DVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg1 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StochasticProcess1DVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StochasticProcess1DVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > > *)new std::vector< ext::shared_ptr< StochasticProcess1D > >(arg1,(std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StochasticProcess1DVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StochasticProcess1DVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_StochasticProcess1DVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StochasticProcess1DVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StochasticProcess1DVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StochasticProcess1DVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StochasticProcess1DVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::vector()\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::vector(std::vector< ext::shared_ptr< StochasticProcess1D > > const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::vector(std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::vector(std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StochasticProcess1DVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *) &((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess1D > *smartresult = *result ? new ext::shared_ptr<  StochasticProcess1D >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *) &((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess1D > *smartresult = *result ? new ext::shared_ptr<  StochasticProcess1D >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess1DVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess1DVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StochasticProcess1DVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcess1DVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::resize(std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::resize(std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StochasticProcess1DVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< StochasticProcess1D > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg3 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StochasticProcess1DVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StochasticProcess1DVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StochasticProcess1DVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StochasticProcess1D_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< StochasticProcess1D > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StochasticProcess1DVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StochasticProcess1DVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StochasticProcess1DVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::insert(std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< StochasticProcess1D > >::insert(std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator,std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type,std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "StochasticProcess1DVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StochasticProcess1DVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StochasticProcess1DVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StochasticProcess1DVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StochasticProcess1D > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StochasticProcess1DVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D > > *arg1 = (std::vector< ext::shared_ptr< StochasticProcess1D > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StochasticProcess1DVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StochasticProcess1D > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StochasticProcess1DVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StochasticProcess1D_t_std__allocatorT_ext__shared_ptrT_StochasticProcess1D_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StochasticProcess1DVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GeneralizedBlackScholesProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  GeneralizedBlackScholesProcess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp4);
  {
    try {
      result = (GeneralizedBlackScholesProcess *)new GeneralizedBlackScholesProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GeneralizedBlackScholesProcess > *smartresult = result ? new ext::shared_ptr<  GeneralizedBlackScholesProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GeneralizedBlackScholesProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  Handle< LocalVolTermStructure > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  GeneralizedBlackScholesProcess *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_LocalVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "5"" of type '" "Handle< LocalVolTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeneralizedBlackScholesProcess" "', argument " "5"" of type '" "Handle< LocalVolTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< LocalVolTermStructure > * >(argp5);
  {
    try {
      result = (GeneralizedBlackScholesProcess *)new GeneralizedBlackScholesProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4,(Handle< LocalVolTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GeneralizedBlackScholesProcess > *smartresult = result ? new ext::shared_ptr<  GeneralizedBlackScholesProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GeneralizedBlackScholesProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedBlackScholesProcess", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_GeneralizedBlackScholesProcess__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_LocalVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_GeneralizedBlackScholesProcess__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedBlackScholesProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GeneralizedBlackScholesProcess::GeneralizedBlackScholesProcess(Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< BlackVolTermStructure > const &)\n"
    "    GeneralizedBlackScholesProcess::GeneralizedBlackScholesProcess(Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< BlackVolTermStructure > const &,Handle< LocalVolTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_stateVariable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedBlackScholesProcess_stateVariable" "', argument " "1"" of type '" "GeneralizedBlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->stateVariable();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_dividendYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedBlackScholesProcess_dividendYield" "', argument " "1"" of type '" "GeneralizedBlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_riskFreeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedBlackScholesProcess_riskFreeRate" "', argument " "1"" of type '" "GeneralizedBlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_blackVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< BlackVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedBlackScholesProcess_blackVolatility" "', argument " "1"" of type '" "GeneralizedBlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->blackVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< BlackVolTermStructure >(result)), SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GeneralizedBlackScholesProcess_localVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedBlackScholesProcess_localVolatility" "', argument " "1"" of type '" "GeneralizedBlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->localVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< LocalVolTermStructure >(result)), SWIGTYPE_p_HandleT_LocalVolTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GeneralizedBlackScholesProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeneralizedBlackScholesProcess *arg1 = (GeneralizedBlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedBlackScholesProcess" "', argument " "1"" of type '" "GeneralizedBlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = const_cast< GeneralizedBlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GeneralizedBlackScholesProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GeneralizedBlackScholesProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackScholesProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  BlackScholesProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackScholesProcess", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackScholesProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackScholesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackScholesProcess" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesProcess" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp3);
  {
    try {
      result = (BlackScholesProcess *)new BlackScholesProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackScholesProcess > *smartresult = result ? new ext::shared_ptr<  BlackScholesProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackScholesProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackScholesProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackScholesProcess *arg1 = (BlackScholesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackScholesProcess > tempshared1 ;
  ext::shared_ptr< BlackScholesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackScholesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackScholesProcess" "', argument " "1"" of type '" "BlackScholesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackScholesProcess > * >(argp1);
      arg1 = const_cast< BlackScholesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackScholesProcess > * >(argp1);
      arg1 = const_cast< BlackScholesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackScholesProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackScholesProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackScholesProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackScholesMertonProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  BlackScholesMertonProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackScholesMertonProcess", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackScholesMertonProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesMertonProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackScholesMertonProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesMertonProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackScholesMertonProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesMertonProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackScholesMertonProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackScholesMertonProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp4);
  {
    try {
      result = (BlackScholesMertonProcess *)new BlackScholesMertonProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackScholesMertonProcess > *smartresult = result ? new ext::shared_ptr<  BlackScholesMertonProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackScholesMertonProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackScholesMertonProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackScholesMertonProcess *arg1 = (BlackScholesMertonProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackScholesMertonProcess > tempshared1 ;
  ext::shared_ptr< BlackScholesMertonProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackScholesMertonProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackScholesMertonProcess" "', argument " "1"" of type '" "BlackScholesMertonProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackScholesMertonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackScholesMertonProcess > * >(argp1);
      arg1 = const_cast< BlackScholesMertonProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackScholesMertonProcess > * >(argp1);
      arg1 = const_cast< BlackScholesMertonProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackScholesMertonProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackScholesMertonProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackScholesMertonProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  BlackProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackProcess", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackProcess" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackProcess" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp3);
  {
    try {
      result = (BlackProcess *)new BlackProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackProcess > *smartresult = result ? new ext::shared_ptr<  BlackProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackProcess *arg1 = (BlackProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackProcess > tempshared1 ;
  ext::shared_ptr< BlackProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackProcess" "', argument " "1"" of type '" "BlackProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackProcess > * >(argp1);
      arg1 = const_cast< BlackProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackProcess > * >(argp1);
      arg1 = const_cast< BlackProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GarmanKohlagenProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  GarmanKohlagenProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GarmanKohlagenProcess", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GarmanKohlagenProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GarmanKohlagenProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GarmanKohlagenProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GarmanKohlagenProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GarmanKohlagenProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GarmanKohlagenProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GarmanKohlagenProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GarmanKohlagenProcess" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp4);
  {
    try {
      result = (GarmanKohlagenProcess *)new GarmanKohlagenProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GarmanKohlagenProcess > *smartresult = result ? new ext::shared_ptr<  GarmanKohlagenProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GarmanKohlagenProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GarmanKohlagenProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKohlagenProcess *arg1 = (GarmanKohlagenProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GarmanKohlagenProcess > tempshared1 ;
  ext::shared_ptr< GarmanKohlagenProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GarmanKohlagenProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GarmanKohlagenProcess" "', argument " "1"" of type '" "GarmanKohlagenProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GarmanKohlagenProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GarmanKohlagenProcess > * >(argp1);
      arg1 = const_cast< GarmanKohlagenProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GarmanKohlagenProcess > * >(argp1);
      arg1 = const_cast< GarmanKohlagenProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GarmanKohlagenProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GarmanKohlagenProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GarmanKohlagenProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Merton76Process(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< BlackVolTermStructure > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< Quote > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  Merton76Process *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Merton76Process", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Merton76Process" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Merton76Process" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Merton76Process" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Merton76Process" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "4"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Merton76Process" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Merton76Process" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Merton76Process" "', argument " "7"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Merton76Process" "', argument " "7"" of type '" "Handle< Quote > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< Quote > * >(argp7);
  {
    try {
      result = (Merton76Process *)new Merton76Process((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< BlackVolTermStructure > const &)*arg4,(Handle< Quote > const &)*arg5,(Handle< Quote > const &)*arg6,(Handle< Quote > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Merton76Process > *smartresult = result ? new ext::shared_ptr<  Merton76Process >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Merton76Process_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Merton76Process(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Merton76Process *arg1 = (Merton76Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Merton76Process > tempshared1 ;
  ext::shared_ptr< Merton76Process > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Merton76Process_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Merton76Process" "', argument " "1"" of type '" "Merton76Process *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Merton76Process > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Merton76Process > * >(argp1);
      arg1 = const_cast< Merton76Process * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Merton76Process > * >(argp1);
      arg1 = const_cast< Merton76Process * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Merton76Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Merton76Process_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Merton76Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StochasticProcessArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *arg1 = 0 ;
  Matrix *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  StochasticProcessArray *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_StochasticProcessArray", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *ptr = (std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StochasticProcessArray" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StochasticProcessArray" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StochasticProcessArray" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StochasticProcessArray" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = (StochasticProcessArray *)new StochasticProcessArray((std::vector< ext::shared_ptr< StochasticProcess1D >,std::allocator< ext::shared_ptr< StochasticProcess1D > > > const &)*arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcessArray > *smartresult = result ? new ext::shared_ptr<  StochasticProcessArray >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StochasticProcessArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StochasticProcessArray *arg1 = (StochasticProcessArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  ext::shared_ptr< StochasticProcessArray > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StochasticProcessArray" "', argument " "1"" of type '" "StochasticProcessArray *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StochasticProcessArray > * >(argp1);
      arg1 = const_cast< StochasticProcessArray * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StochasticProcessArray > * >(argp1);
      arg1 = const_cast< StochasticProcessArray * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StochasticProcessArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StochasticProcessArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GeometricBrownianMotionProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  GeometricBrownianMotionProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GeometricBrownianMotionProcess", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeometricBrownianMotionProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GeometricBrownianMotionProcess" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GeometricBrownianMotionProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (GeometricBrownianMotionProcess *)new GeometricBrownianMotionProcess(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GeometricBrownianMotionProcess > *smartresult = result ? new ext::shared_ptr<  GeometricBrownianMotionProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GeometricBrownianMotionProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GeometricBrownianMotionProcess *arg1 = (GeometricBrownianMotionProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GeometricBrownianMotionProcess > tempshared1 ;
  ext::shared_ptr< GeometricBrownianMotionProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeometricBrownianMotionProcess" "', argument " "1"" of type '" "GeometricBrownianMotionProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GeometricBrownianMotionProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GeometricBrownianMotionProcess > * >(argp1);
      arg1 = const_cast< GeometricBrownianMotionProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GeometricBrownianMotionProcess > * >(argp1);
      arg1 = const_cast< GeometricBrownianMotionProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GeometricBrownianMotionProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GeometricBrownianMotionProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GeometricBrownianMotionProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VarianceGammaProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  VarianceGammaProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VarianceGammaProcess", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VarianceGammaProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VarianceGammaProcess" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VarianceGammaProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VarianceGammaProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VarianceGammaProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VarianceGammaProcess" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VarianceGammaProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_VarianceGammaProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_VarianceGammaProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (VarianceGammaProcess *)new VarianceGammaProcess((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VarianceGammaProcess > *smartresult = result ? new ext::shared_ptr<  VarianceGammaProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VarianceGammaProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VarianceGammaProcess *arg1 = (VarianceGammaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VarianceGammaProcess > tempshared1 ;
  ext::shared_ptr< VarianceGammaProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VarianceGammaProcess" "', argument " "1"" of type '" "VarianceGammaProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VarianceGammaProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VarianceGammaProcess > * >(argp1);
      arg1 = const_cast< VarianceGammaProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VarianceGammaProcess > * >(argp1);
      arg1 = const_cast< VarianceGammaProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VarianceGammaProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VarianceGammaProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  HestonProcess::Discretization arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 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 ;
  int val9 ;
  int ecode9 = 0 ;
  HestonProcess *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HestonProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonProcess" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HestonProcess" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HestonProcess" "', argument " "9"" of type '" "HestonProcess::Discretization""'");
  } 
  arg9 = static_cast< HestonProcess::Discretization >(val9);
  {
    try {
      result = (HestonProcess *)new HestonProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonProcess > *smartresult = result ? new ext::shared_ptr<  HestonProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 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 ;
  HestonProcess *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HestonProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonProcess" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HestonProcess" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (HestonProcess *)new HestonProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonProcess > *smartresult = result ? new ext::shared_ptr<  HestonProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonProcess", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_HestonProcess__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_HestonProcess__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonProcess::HestonProcess(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &,Real,Real,Real,Real,Real,HestonProcess::Discretization)\n"
    "    HestonProcess::HestonProcess(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HestonProcess_s0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonProcess_s0" "', argument " "1"" of type '" "HestonProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->s0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonProcess_dividendYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonProcess_dividendYield" "', argument " "1"" of type '" "HestonProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonProcess_riskFreeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonProcess_riskFreeRate" "', argument " "1"" of type '" "HestonProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonProcess *arg1 = (HestonProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  ext::shared_ptr< HestonProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonProcess" "', argument " "1"" of type '" "HestonProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonProcess > * >(argp1);
      arg1 = const_cast< HestonProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BatesProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject *swig_obj[11] ;
  BatesProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BatesProcess", 11, 11, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BatesProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BatesProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BatesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BatesProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BatesProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BatesProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BatesProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BatesProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_BatesProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_BatesProcess" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_BatesProcess" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_BatesProcess" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_BatesProcess" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_BatesProcess" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (BatesProcess *)new BatesProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BatesProcess > *smartresult = result ? new ext::shared_ptr<  BatesProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BatesProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BatesProcess *arg1 = (BatesProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesProcess > tempshared1 ;
  ext::shared_ptr< BatesProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BatesProcess" "', argument " "1"" of type '" "BatesProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BatesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BatesProcess > * >(argp1);
      arg1 = const_cast< BatesProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BatesProcess > * >(argp1);
      arg1 = const_cast< BatesProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BatesProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BatesProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HullWhiteProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  HullWhiteProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HullWhiteProcess", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HullWhiteProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HullWhiteProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HullWhiteProcess" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HullWhiteProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (HullWhiteProcess *)new HullWhiteProcess((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HullWhiteProcess > *smartresult = result ? new ext::shared_ptr<  HullWhiteProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HullWhiteProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhiteProcess *arg1 = (HullWhiteProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > tempshared1 ;
  ext::shared_ptr< HullWhiteProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HullWhiteProcess" "', argument " "1"" of type '" "HullWhiteProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HullWhiteProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HullWhiteProcess > * >(argp1);
      arg1 = const_cast< HullWhiteProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HullWhiteProcess > * >(argp1);
      arg1 = const_cast< HullWhiteProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HullWhiteProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HullWhiteProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HullWhiteForwardProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  HullWhiteForwardProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HullWhiteForwardProcess", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HullWhiteForwardProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HullWhiteForwardProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HullWhiteForwardProcess" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HullWhiteForwardProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (HullWhiteForwardProcess *)new HullWhiteForwardProcess((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HullWhiteForwardProcess > *smartresult = result ? new ext::shared_ptr<  HullWhiteForwardProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HullWhiteForwardProcess_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhiteForwardProcess const > tempshared1 ;
  ext::shared_ptr< HullWhiteForwardProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "HullWhiteForwardProcess_alpha", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HullWhiteForwardProcess_alpha" "', argument " "1"" of type '" "HullWhiteForwardProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HullWhiteForwardProcess_alpha" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((HullWhiteForwardProcess const *)arg1)->alpha(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HullWhiteForwardProcess_M_T(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhiteForwardProcess const > tempshared1 ;
  ext::shared_ptr< HullWhiteForwardProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "HullWhiteForwardProcess_M_T", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HullWhiteForwardProcess_M_T" "', argument " "1"" of type '" "HullWhiteForwardProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HullWhiteForwardProcess_M_T" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HullWhiteForwardProcess_M_T" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HullWhiteForwardProcess_M_T" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((HullWhiteForwardProcess const *)arg1)->M_T(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HullWhiteForwardProcess_B(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhiteForwardProcess const > tempshared1 ;
  ext::shared_ptr< HullWhiteForwardProcess const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "HullWhiteForwardProcess_B", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HullWhiteForwardProcess_B" "', argument " "1"" of type '" "HullWhiteForwardProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HullWhiteForwardProcess_B" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HullWhiteForwardProcess_B" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((HullWhiteForwardProcess const *)arg1)->B(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HullWhiteForwardProcess_setForwardMeasureTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhiteForwardProcess > tempshared1 ;
  ext::shared_ptr< HullWhiteForwardProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "HullWhiteForwardProcess_setForwardMeasureTime", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HullWhiteForwardProcess_setForwardMeasureTime" "', argument " "1"" of type '" "HullWhiteForwardProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HullWhiteForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HullWhiteForwardProcess_setForwardMeasureTime" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setForwardMeasureTime(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HullWhiteForwardProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhiteForwardProcess *arg1 = (HullWhiteForwardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhiteForwardProcess > tempshared1 ;
  ext::shared_ptr< HullWhiteForwardProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HullWhiteForwardProcess" "', argument " "1"" of type '" "HullWhiteForwardProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HullWhiteForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HullWhiteForwardProcess > * >(argp1);
      arg1 = const_cast< HullWhiteForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HullWhiteForwardProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HullWhiteForwardProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HullWhiteForwardProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_G2Process(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real 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 *swig_obj[5] ;
  G2Process *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_G2Process", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_G2Process" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2Process" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2Process" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_G2Process" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_G2Process" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (G2Process *)new G2Process(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2Process > *smartresult = result ? new ext::shared_ptr<  G2Process >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2Process_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_G2Process(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  G2Process *arg1 = (G2Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< G2Process > tempshared1 ;
  ext::shared_ptr< G2Process > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2Process_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_G2Process" "', argument " "1"" of type '" "G2Process *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  G2Process > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  G2Process > * >(argp1);
      arg1 = const_cast< G2Process * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  G2Process > * >(argp1);
      arg1 = const_cast< G2Process * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *G2Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_G2Process_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *G2Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_G2ForwardProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real 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 *swig_obj[5] ;
  G2ForwardProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_G2ForwardProcess", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_G2ForwardProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2ForwardProcess" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2ForwardProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_G2ForwardProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_G2ForwardProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (G2ForwardProcess *)new G2ForwardProcess(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2ForwardProcess > *smartresult = result ? new ext::shared_ptr<  G2ForwardProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2ForwardProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_G2ForwardProcess_setForwardMeasureTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  G2ForwardProcess *arg1 = (G2ForwardProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< G2ForwardProcess > tempshared1 ;
  ext::shared_ptr< G2ForwardProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "G2ForwardProcess_setForwardMeasureTime", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2ForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "G2ForwardProcess_setForwardMeasureTime" "', argument " "1"" of type '" "G2ForwardProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  G2ForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  G2ForwardProcess > * >(argp1);
      arg1 = const_cast< G2ForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  G2ForwardProcess > * >(argp1);
      arg1 = const_cast< G2ForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "G2ForwardProcess_setForwardMeasureTime" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setForwardMeasureTime(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_G2ForwardProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  G2ForwardProcess *arg1 = (G2ForwardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< G2ForwardProcess > tempshared1 ;
  ext::shared_ptr< G2ForwardProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2ForwardProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_G2ForwardProcess" "', argument " "1"" of type '" "G2ForwardProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  G2ForwardProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  G2ForwardProcess > * >(argp1);
      arg1 = const_cast< G2ForwardProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  G2ForwardProcess > * >(argp1);
      arg1 = const_cast< G2ForwardProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *G2ForwardProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_G2ForwardProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *G2ForwardProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GsrProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  GsrProcess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GsrProcess" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GsrProcess" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GsrProcess" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GsrProcess" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GsrProcess" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GsrProcess" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GsrProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (GsrProcess *)new GsrProcess((Array const &)*arg1,(Array const &)*arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GsrProcess > *smartresult = result ? new ext::shared_ptr<  GsrProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GsrProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  GsrProcess *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GsrProcess" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GsrProcess" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GsrProcess" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GsrProcess" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GsrProcess" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GsrProcess" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = (GsrProcess *)new GsrProcess((Array const &)*arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GsrProcess > *smartresult = result ? new ext::shared_ptr<  GsrProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GsrProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GsrProcess", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_new_GsrProcess__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GsrProcess__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GsrProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GsrProcess::GsrProcess(Array const &,Array const &,Array const &,Real const)\n"
    "    GsrProcess::GsrProcess(Array const &,Array const &,Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GsrProcess_sigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GsrProcess > tempshared1 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GsrProcess_sigma", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GsrProcess_sigma" "', argument " "1"" of type '" "GsrProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GsrProcess_sigma" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(arg1)->sigma(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GsrProcess_reversion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GsrProcess > tempshared1 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GsrProcess_reversion", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GsrProcess_reversion" "', argument " "1"" of type '" "GsrProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GsrProcess_reversion" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(arg1)->reversion(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GsrProcess_y(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GsrProcess > tempshared1 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GsrProcess_y", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GsrProcess_y" "', argument " "1"" of type '" "GsrProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GsrProcess_y" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(arg1)->y(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GsrProcess_G(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GsrProcess > tempshared1 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GsrProcess_G", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GsrProcess_G" "', argument " "1"" of type '" "GsrProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GsrProcess_G" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GsrProcess_G" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GsrProcess_G" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)(arg1)->G(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GsrProcess_setForwardMeasureTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GsrProcess > tempshared1 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "GsrProcess_setForwardMeasureTime", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GsrProcess_setForwardMeasureTime" "', argument " "1"" of type '" "GsrProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GsrProcess_setForwardMeasureTime" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setForwardMeasureTime(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GsrProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GsrProcess *arg1 = (GsrProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GsrProcess > tempshared1 ;
  ext::shared_ptr< GsrProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GsrProcess" "', argument " "1"" of type '" "GsrProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GsrProcess > * >(argp1);
      arg1 = const_cast< GsrProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GsrProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GsrProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_gsr_process(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< GsrProcess > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_gsr_process" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_gsr_process((ext::shared_ptr< StochasticProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GsrProcess > *smartresult = result ? new ext::shared_ptr<  GsrProcess >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GsrProcess_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrnsteinUhlenbeckProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  OrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (OrnsteinUhlenbeckProcess *)new OrnsteinUhlenbeckProcess(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  OrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrnsteinUhlenbeckProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  OrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (OrnsteinUhlenbeckProcess *)new OrnsteinUhlenbeckProcess(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  OrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrnsteinUhlenbeckProcess__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  OrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  {
    try {
      result = (OrnsteinUhlenbeckProcess *)new OrnsteinUhlenbeckProcess(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  OrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrnsteinUhlenbeckProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OrnsteinUhlenbeckProcess", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrnsteinUhlenbeckProcess__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_OrnsteinUhlenbeckProcess__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_OrnsteinUhlenbeckProcess__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OrnsteinUhlenbeckProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OrnsteinUhlenbeckProcess::OrnsteinUhlenbeckProcess(Real,Volatility,Real,Real)\n"
    "    OrnsteinUhlenbeckProcess::OrnsteinUhlenbeckProcess(Real,Volatility,Real)\n"
    "    OrnsteinUhlenbeckProcess::OrnsteinUhlenbeckProcess(Real,Volatility)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OrnsteinUhlenbeckProcess_speed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > tempshared1 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrnsteinUhlenbeckProcess_speed" "', argument " "1"" of type '" "OrnsteinUhlenbeckProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OrnsteinUhlenbeckProcess const *)arg1)->speed();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrnsteinUhlenbeckProcess_volatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > tempshared1 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrnsteinUhlenbeckProcess_volatility" "', argument " "1"" of type '" "OrnsteinUhlenbeckProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OrnsteinUhlenbeckProcess const *)arg1)->volatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OrnsteinUhlenbeckProcess_level(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > tempshared1 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrnsteinUhlenbeckProcess_level" "', argument " "1"" of type '" "OrnsteinUhlenbeckProcess const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OrnsteinUhlenbeckProcess const *)arg1)->level();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OrnsteinUhlenbeckProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OrnsteinUhlenbeckProcess *arg1 = (OrnsteinUhlenbeckProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "OrnsteinUhlenbeckProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< OrnsteinUhlenbeckProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrnsteinUhlenbeckProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OrnsteinUhlenbeckProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  ext::function< Real (Real) > *arg4 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess::Discretization arg5 ;
  Real arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ext__functionT_double_fdoubleF_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  arg4 = reinterpret_cast< ext::function< Real (Real) > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "5"" of type '" "ExtendedOrnsteinUhlenbeckProcess::Discretization""'");
  } 
  arg5 = static_cast< ExtendedOrnsteinUhlenbeckProcess::Discretization >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new ExtendedOrnsteinUhlenbeckProcess(arg1,arg2,arg3,(ext::function< Real (Real) > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  ext::function< Real (Real) > *arg4 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess::Discretization arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ext__functionT_double_fdoubleF_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  arg4 = reinterpret_cast< ext::function< Real (Real) > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "5"" of type '" "ExtendedOrnsteinUhlenbeckProcess::Discretization""'");
  } 
  arg5 = static_cast< ExtendedOrnsteinUhlenbeckProcess::Discretization >(val5);
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new ExtendedOrnsteinUhlenbeckProcess(arg1,arg2,arg3,(ext::function< Real (Real) > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  ext::function< Real (Real) > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ext__functionT_double_fdoubleF_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "4"" of type '" "ext::function< Real (Real) > const &""'"); 
  }
  arg4 = reinterpret_cast< ext::function< Real (Real) > * >(argp4);
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new ExtendedOrnsteinUhlenbeckProcess(arg1,arg2,arg3,(ext::function< Real (Real) > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  PyObject *arg4 = (PyObject *) 0 ;
  Real arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  arg4 = swig_obj[3];
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Volatility arg2 ;
  Real arg3 ;
  PyObject *arg4 = (PyObject *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ExtendedOrnsteinUhlenbeckProcess *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedOrnsteinUhlenbeckProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  arg4 = swig_obj[3];
  {
    try {
      result = (ExtendedOrnsteinUhlenbeckProcess *)new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > *smartresult = result ? new ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedOrnsteinUhlenbeckProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExtendedOrnsteinUhlenbeckProcess", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__functionT_double_fdoubleF_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__functionT_double_fdoubleF_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__functionT_double_fdoubleF_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ExtendedOrnsteinUhlenbeckProcess__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExtendedOrnsteinUhlenbeckProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExtendedOrnsteinUhlenbeckProcess::ExtendedOrnsteinUhlenbeckProcess(Real,Volatility,Real,ext::function< Real (Real) > const &,ExtendedOrnsteinUhlenbeckProcess::Discretization,Real)\n"
    "    ExtendedOrnsteinUhlenbeckProcess::ExtendedOrnsteinUhlenbeckProcess(Real,Volatility,Real,ext::function< Real (Real) > const &,ExtendedOrnsteinUhlenbeckProcess::Discretization)\n"
    "    ExtendedOrnsteinUhlenbeckProcess::ExtendedOrnsteinUhlenbeckProcess(Real,Volatility,Real,ext::function< Real (Real) > const &)\n"
    "    ExtendedOrnsteinUhlenbeckProcess::ExtendedOrnsteinUhlenbeckProcess(Real,Volatility,Real,PyObject *,Real)\n"
    "    ExtendedOrnsteinUhlenbeckProcess::ExtendedOrnsteinUhlenbeckProcess(Real,Volatility,Real,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExtendedOrnsteinUhlenbeckProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExtendedOrnsteinUhlenbeckProcess *arg1 = (ExtendedOrnsteinUhlenbeckProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > tempshared1 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExtendedOrnsteinUhlenbeckProcess" "', argument " "1"" of type '" "ExtendedOrnsteinUhlenbeckProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< ExtendedOrnsteinUhlenbeckProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExtendedOrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = const_cast< ExtendedOrnsteinUhlenbeckProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExtendedOrnsteinUhlenbeckProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExtendedOrnsteinUhlenbeckProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExtOUWithJumpsProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  ExtOUWithJumpsProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ExtOUWithJumpsProcess", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtOUWithJumpsProcess" "', argument " "1"" of type '" "ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtOUWithJumpsProcess" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtOUWithJumpsProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExtOUWithJumpsProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExtOUWithJumpsProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (ExtOUWithJumpsProcess *)new ExtOUWithJumpsProcess((ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtOUWithJumpsProcess > *smartresult = result ? new ext::shared_ptr<  ExtOUWithJumpsProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExtOUWithJumpsProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExtOUWithJumpsProcess *arg1 = (ExtOUWithJumpsProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExtOUWithJumpsProcess" "', argument " "1"" of type '" "ExtOUWithJumpsProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExtOUWithJumpsProcess > * >(argp1);
      arg1 = const_cast< ExtOUWithJumpsProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExtOUWithJumpsProcess > * >(argp1);
      arg1 = const_cast< ExtOUWithJumpsProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExtOUWithJumpsProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExtOUWithJumpsProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KlugeExtOUProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg2 = 0 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > tempshared3 ;
  PyObject *swig_obj[3] ;
  KlugeExtOUProcess *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KlugeExtOUProcess", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KlugeExtOUProcess" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KlugeExtOUProcess" "', argument " "2"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KlugeExtOUProcess" "', argument " "3"" of type '" "ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (KlugeExtOUProcess *)new KlugeExtOUProcess(arg1,(ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg2,(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KlugeExtOUProcess > *smartresult = result ? new ext::shared_ptr<  KlugeExtOUProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KlugeExtOUProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KlugeExtOUProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KlugeExtOUProcess *arg1 = (KlugeExtOUProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KlugeExtOUProcess > tempshared1 ;
  ext::shared_ptr< KlugeExtOUProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KlugeExtOUProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KlugeExtOUProcess" "', argument " "1"" of type '" "KlugeExtOUProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  KlugeExtOUProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  KlugeExtOUProcess > * >(argp1);
      arg1 = const_cast< KlugeExtOUProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  KlugeExtOUProcess > * >(argp1);
      arg1 = const_cast< KlugeExtOUProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KlugeExtOUProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_KlugeExtOUProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KlugeExtOUProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GJRGARCHProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  GJRGARCHProcess::Discretization arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  GJRGARCHProcess *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GJRGARCHProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GJRGARCHProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GJRGARCHProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GJRGARCHProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GJRGARCHProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GJRGARCHProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GJRGARCHProcess" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GJRGARCHProcess" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GJRGARCHProcess" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GJRGARCHProcess" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_GJRGARCHProcess" "', argument " "11"" of type '" "GJRGARCHProcess::Discretization""'");
  } 
  arg11 = static_cast< GJRGARCHProcess::Discretization >(val11);
  {
    try {
      result = (GJRGARCHProcess *)new GJRGARCHProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GJRGARCHProcess > *smartresult = result ? new ext::shared_ptr<  GJRGARCHProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GJRGARCHProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  GJRGARCHProcess *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GJRGARCHProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GJRGARCHProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GJRGARCHProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GJRGARCHProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GJRGARCHProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GJRGARCHProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GJRGARCHProcess" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GJRGARCHProcess" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GJRGARCHProcess" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_GJRGARCHProcess" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (GJRGARCHProcess *)new GJRGARCHProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GJRGARCHProcess > *smartresult = result ? new ext::shared_ptr<  GJRGARCHProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GJRGARCHProcess__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  GJRGARCHProcess *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GJRGARCHProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GJRGARCHProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GJRGARCHProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GJRGARCHProcess" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GJRGARCHProcess" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GJRGARCHProcess" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GJRGARCHProcess" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_GJRGARCHProcess" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_GJRGARCHProcess" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_GJRGARCHProcess" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (GJRGARCHProcess *)new GJRGARCHProcess((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GJRGARCHProcess > *smartresult = result ? new ext::shared_ptr<  GJRGARCHProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GJRGARCHProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GJRGARCHProcess", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_GJRGARCHProcess__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_GJRGARCHProcess__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_GJRGARCHProcess__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GJRGARCHProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GJRGARCHProcess::GJRGARCHProcess(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &,Real,Real,Real,Real,Real,Real,Real,GJRGARCHProcess::Discretization)\n"
    "    GJRGARCHProcess::GJRGARCHProcess(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &,Real,Real,Real,Real,Real,Real,Real)\n"
    "    GJRGARCHProcess::GJRGARCHProcess(Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &,Real,Real,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GJRGARCHProcess_s0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHProcess_s0" "', argument " "1"" of type '" "GJRGARCHProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->s0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHProcess_dividendYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHProcess_dividendYield" "', argument " "1"" of type '" "GJRGARCHProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHProcess_riskFreeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHProcess_riskFreeRate" "', argument " "1"" of type '" "GJRGARCHProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GJRGARCHProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHProcess *arg1 = (GJRGARCHProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  ext::shared_ptr< GJRGARCHProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GJRGARCHProcess" "', argument " "1"" of type '" "GJRGARCHProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GJRGARCHProcess > * >(argp1);
      arg1 = const_cast< GJRGARCHProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GJRGARCHProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GJRGARCHProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_LazyObject_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LazyObject *arg1 = (LazyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LazyObject > tempshared1 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LazyObject_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyObject_recalculate" "', argument " "1"" of type '" "LazyObject *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyObject_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LazyObject *arg1 = (LazyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LazyObject > tempshared1 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LazyObject_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyObject_freeze" "', argument " "1"" of type '" "LazyObject *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyObject_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LazyObject *arg1 = (LazyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LazyObject > tempshared1 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LazyObject_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LazyObject_unfreeze" "', argument " "1"" of type '" "LazyObject *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyObject_forwardFirstNotificationOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyObject_forwardFirstNotificationOnly", 0, 0, 0)) SWIG_fail;
  {
    try {
      LazyObject_forwardFirstNotificationOnly();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyObject_alwaysForwardNotifications(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyObject_alwaysForwardNotifications", 0, 0, 0)) SWIG_fail;
  {
    try {
      LazyObject_alwaysForwardNotifications();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LazyObject_forwardsAllNotifications(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "LazyObject_forwardsAllNotifications", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)LazyObject_forwardsAllNotifications();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LazyObject(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LazyObject *arg1 = (LazyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LazyObject > tempshared1 ;
  ext::shared_ptr< LazyObject > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LazyObject_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LazyObject" "', argument " "1"" of type '" "LazyObject *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LazyObject > * >(argp1);
      arg1 = const_cast< LazyObject * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LazyObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LazyObject_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_PricingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PricingEngine *arg1 = (PricingEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared1 ;
  ext::shared_ptr< PricingEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PricingEngine" "', argument " "1"" of type '" "PricingEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PricingEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PricingEngine > * >(argp1);
      arg1 = const_cast< PricingEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PricingEngine > * >(argp1);
      arg1 = const_cast< PricingEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PricingEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Instrument_NPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Instrument *arg1 = (Instrument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Instrument const > tempshared1 ;
  ext::shared_ptr< Instrument const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instrument_NPV" "', argument " "1"" of type '" "Instrument const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Instrument const *)arg1)->NPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instrument_errorEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Instrument *arg1 = (Instrument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Instrument const > tempshared1 ;
  ext::shared_ptr< Instrument const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instrument_errorEstimate" "', argument " "1"" of type '" "Instrument const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Instrument const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instrument_isExpired(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Instrument *arg1 = (Instrument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Instrument const > tempshared1 ;
  ext::shared_ptr< Instrument const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instrument_isExpired" "', argument " "1"" of type '" "Instrument const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((Instrument const *)arg1)->isExpired();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Instrument_setPricingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Instrument *arg1 = (Instrument *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Instrument > tempshared1 ;
  ext::shared_ptr< Instrument > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Instrument_setPricingEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Instrument_setPricingEngine" "', argument " "1"" of type '" "Instrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Instrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Instrument_setPricingEngine" "', argument " "2"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setPricingEngine((ext::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Instrument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Instrument *arg1 = (Instrument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Instrument > tempshared1 ;
  ext::shared_ptr< Instrument > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Instrument" "', argument " "1"" of type '" "Instrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Instrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Instrument > * >(argp1);
      arg1 = const_cast< Instrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Instrument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Instrument_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_InstrumentVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< Instrument > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____bool__((std::vector< ext::shared_ptr< Instrument > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____len__((std::vector< ext::shared_ptr< Instrument > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InstrumentVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InstrumentVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InstrumentVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *ptr = (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstrumentVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InstrumentVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstrumentVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InstrumentVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__setslice__(std::vector< ext::shared_ptr< Instrument > >::difference_type,std::vector< ext::shared_ptr< Instrument > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__setslice__(std::vector< ext::shared_ptr< Instrument > >::difference_type,std::vector< ext::shared_ptr< Instrument > >::difference_type,std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InstrumentVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *)std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *ptr = (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstrumentVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InstrumentVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_InstrumentVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InstrumentVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__delitem__(std::vector< ext::shared_ptr< Instrument > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Instrument > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< Instrument > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Instrument > *smartresult = *result ? new ext::shared_ptr<  Instrument >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Instrument_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Instrument > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_InstrumentVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InstrumentVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__getitem__(std::vector< ext::shared_ptr< Instrument > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstrumentVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Instrument > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_InstrumentVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InstrumentVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InstrumentVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::__setitem__(std::vector< ext::shared_ptr< Instrument > >::difference_type,std::vector< ext::shared_ptr< Instrument > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Instrument > *smartresult = result ? new ext::shared_ptr<  Instrument >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Instrument_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstrumentVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__append(arg1,(ext::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > > *)new std::vector< ext::shared_ptr< Instrument > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *ptr = (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrumentVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrumentVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > > *)new std::vector< ext::shared_ptr< Instrument > >((std::vector< ext::shared_ptr< Instrument > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< Instrument > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Instrument > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstrumentVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InstrumentVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< Instrument > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Instrument > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< Instrument > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Instrument_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InstrumentVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > > *)new std::vector< ext::shared_ptr< Instrument > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_InstrumentVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_InstrumentVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::erase(std::vector< ext::shared_ptr< Instrument > >::iterator)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::erase(std::vector< ext::shared_ptr< Instrument > >::iterator,std::vector< ext::shared_ptr< Instrument > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_InstrumentVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg1 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< Instrument > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InstrumentVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InstrumentVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > > *)new std::vector< ext::shared_ptr< Instrument > >(arg1,(std::vector< ext::shared_ptr< Instrument > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InstrumentVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InstrumentVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InstrumentVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InstrumentVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InstrumentVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::vector()\n"
    "    std::vector< ext::shared_ptr< Instrument > >::vector(std::vector< ext::shared_ptr< Instrument > > const &)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::vector(std::vector< ext::shared_ptr< Instrument > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::vector(std::vector< ext::shared_ptr< Instrument > >::size_type,std::vector< ext::shared_ptr< Instrument > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InstrumentVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< Instrument > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > >::value_type *) &((std::vector< ext::shared_ptr< Instrument > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Instrument > *smartresult = *result ? new ext::shared_ptr<  Instrument >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Instrument_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Instrument > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Instrument > >::value_type *) &((std::vector< ext::shared_ptr< Instrument > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Instrument > *smartresult = *result ? new ext::shared_ptr<  Instrument >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Instrument_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Instrument > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstrumentVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< Instrument > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstrumentVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< Instrument > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InstrumentVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InstrumentVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::resize(std::vector< ext::shared_ptr< Instrument > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::resize(std::vector< ext::shared_ptr< Instrument > >::size_type,std::vector< ext::shared_ptr< Instrument > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InstrumentVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Instrument > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Instrument > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg3 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< Instrument > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "InstrumentVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InstrumentVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InstrumentVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Instrument > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< Instrument > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Instrument_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< Instrument > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InstrumentVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InstrumentVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Instrument > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InstrumentVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InstrumentVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Instrument > >::insert(std::vector< ext::shared_ptr< Instrument > >::iterator,std::vector< ext::shared_ptr< Instrument > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< Instrument > >::insert(std::vector< ext::shared_ptr< Instrument > >::iterator,std::vector< ext::shared_ptr< Instrument > >::size_type,std::vector< ext::shared_ptr< Instrument > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  std::vector< ext::shared_ptr< Instrument > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "InstrumentVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InstrumentVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Instrument > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InstrumentVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Instrument > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InstrumentVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Instrument > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InstrumentVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Instrument > > *arg1 = (std::vector< ext::shared_ptr< Instrument > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrumentVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Instrument > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Instrument > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrumentVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Instrument_t_std__allocatorT_ext__shared_ptrT_Instrument_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InstrumentVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Stock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Stock *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Stock" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Stock" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    try {
      result = (Stock *)new Stock((Handle< Quote > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Stock > *smartresult = result ? new ext::shared_ptr<  Stock >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Stock_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Stock(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Stock *arg1 = (Stock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Stock > tempshared1 ;
  ext::shared_ptr< Stock > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Stock_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Stock" "', argument " "1"" of type '" "Stock *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Stock > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Stock > * >(argp1);
      arg1 = const_cast< Stock * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Stock > * >(argp1);
      arg1 = const_cast< Stock * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Stock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Stock_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Stock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CompositeInstrument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompositeInstrument *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CompositeInstrument", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (CompositeInstrument *)new CompositeInstrument();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompositeInstrument > *smartresult = result ? new ext::shared_ptr<  CompositeInstrument >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompositeInstrument_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeInstrument > tempshared1 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Instrument > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeInstrument_add" "', argument " "1"" of type '" "CompositeInstrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeInstrument_add" "', argument " "2"" of type '" "ext::shared_ptr< Instrument > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CompositeInstrument_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((ext::shared_ptr< Instrument > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompositeInstrument_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeInstrument > tempshared1 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Instrument > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeInstrument_add" "', argument " "1"" of type '" "CompositeInstrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeInstrument_add" "', argument " "2"" of type '" "ext::shared_ptr< Instrument > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->add((ext::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompositeInstrument_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CompositeInstrument_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CompositeInstrument_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositeInstrument_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CompositeInstrument_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CompositeInstrument::add(ext::shared_ptr< Instrument > const &,Real)\n"
    "    CompositeInstrument::add(ext::shared_ptr< Instrument > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CompositeInstrument_subtract__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeInstrument > tempshared1 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Instrument > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeInstrument_subtract" "', argument " "1"" of type '" "CompositeInstrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeInstrument_subtract" "', argument " "2"" of type '" "ext::shared_ptr< Instrument > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CompositeInstrument_subtract" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->subtract((ext::shared_ptr< Instrument > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompositeInstrument_subtract__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  ext::shared_ptr< Instrument > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeInstrument > tempshared1 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Instrument > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeInstrument_subtract" "', argument " "1"" of type '" "CompositeInstrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Instrument_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeInstrument_subtract" "', argument " "2"" of type '" "ext::shared_ptr< Instrument > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Instrument > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->subtract((ext::shared_ptr< Instrument > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CompositeInstrument_subtract(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CompositeInstrument_subtract", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CompositeInstrument_subtract__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Instrument_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositeInstrument_subtract__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CompositeInstrument_subtract'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CompositeInstrument::subtract(ext::shared_ptr< Instrument > const &,Real)\n"
    "    CompositeInstrument::subtract(ext::shared_ptr< Instrument > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CompositeInstrument(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompositeInstrument *arg1 = (CompositeInstrument *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompositeInstrument > tempshared1 ;
  ext::shared_ptr< CompositeInstrument > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositeInstrument" "', argument " "1"" of type '" "CompositeInstrument *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompositeInstrument > * >(argp1);
      arg1 = const_cast< CompositeInstrument * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompositeInstrument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CompositeInstrument_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompositeInstrument_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CalibrationHelper_calibrationError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempshared1 ;
  ext::shared_ptr< CalibrationHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelper_calibrationError" "', argument " "1"" of type '" "CalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibrationHelper > * >(argp1);
      arg1 = const_cast< CalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibrationHelper > * >(argp1);
      arg1 = const_cast< CalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->calibrationError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibrationHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibrationHelper *arg1 = (CalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempshared1 ;
  ext::shared_ptr< CalibrationHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibrationHelper" "', argument " "1"" of type '" "CalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibrationHelper > * >(argp1);
      arg1 = const_cast< CalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibrationHelper > * >(argp1);
      arg1 = const_cast< CalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibrationHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_CalibrationHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____bool__((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____len__((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibrationHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CalibrationHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalibrationHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__setslice__(std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__setslice__(std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalibrationHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalibrationHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__delitem__(std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CalibrationHelper > *smartresult = *result ? new ext::shared_ptr<  CalibrationHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CalibrationHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalibrationHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalibrationHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__getitem__(std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< CalibrationHelper > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalibrationHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::__setitem__(std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CalibrationHelper > *smartresult = result ? new ext::shared_ptr<  CalibrationHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__append(arg1,(ext::shared_ptr< CalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new std::vector< ext::shared_ptr< CalibrationHelper > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new std::vector< ext::shared_ptr< CalibrationHelper > >((std::vector< ext::shared_ptr< CalibrationHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< CalibrationHelper > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< CalibrationHelper > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new std::vector< ext::shared_ptr< CalibrationHelper > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_CalibrationHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_CalibrationHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::erase(std::vector< ext::shared_ptr< CalibrationHelper > >::iterator)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::erase(std::vector< ext::shared_ptr< CalibrationHelper > >::iterator,std::vector< ext::shared_ptr< CalibrationHelper > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CalibrationHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg1 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CalibrationHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > > *)new std::vector< ext::shared_ptr< CalibrationHelper > >(arg1,(std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CalibrationHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CalibrationHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CalibrationHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalibrationHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CalibrationHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CalibrationHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::vector()\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::vector(std::vector< ext::shared_ptr< CalibrationHelper > > const &)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::vector(std::vector< ext::shared_ptr< CalibrationHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::vector(std::vector< ext::shared_ptr< CalibrationHelper > >::size_type,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *) &((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CalibrationHelper > *smartresult = *result ? new ext::shared_ptr<  CalibrationHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CalibrationHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *) &((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CalibrationHelper > *smartresult = *result ? new ext::shared_ptr<  CalibrationHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< CalibrationHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalibrationHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::resize(std::vector< ext::shared_ptr< CalibrationHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::resize(std::vector< ext::shared_ptr< CalibrationHelper > >::size_type,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< CalibrationHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< CalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg3 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibrationHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_CalibrationHelper_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< CalibrationHelper > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< CalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalibrationHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::insert(std::vector< ext::shared_ptr< CalibrationHelper > >::iterator,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< CalibrationHelper > >::insert(std::vector< ext::shared_ptr< CalibrationHelper > >::iterator,std::vector< ext::shared_ptr< CalibrationHelper > >::size_type,std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< CalibrationHelper > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CalibrationHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< CalibrationHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibrationHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< CalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< CalibrationHelper > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibrationHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_CalibrationHelper_t_std__allocatorT_ext__shared_ptrT_CalibrationHelper_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CalibrationHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CalibratedModel_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel const > tempshared1 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_params" "', argument " "1"" of type '" "CalibratedModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CalibratedModel const *)arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_calibrate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_calibrate" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CalibratedModel_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CalibratedModel_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CalibratedModel_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(std::vector< bool,std::allocator< bool > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_calibrate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_calibrate" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CalibratedModel_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CalibratedModel_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_calibrate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_calibrate" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CalibratedModel_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_calibrate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_calibrate" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_calibrate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibratedModel_calibrate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalibratedModel_calibrate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CalibratedModel_calibrate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_CalibratedModel_calibrate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector<bool,std::allocator< bool > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CalibratedModel_calibrate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibratedModel_calibrate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &,std::vector< bool,std::allocator< bool > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_setParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibratedModel_setParams", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_setParams" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModel_setParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_setParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibratedModel_value", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_value" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModel_value" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_value" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModel_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModel_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Real)(arg1)->value((Array const &)*arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel const > tempshared1 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_constraint" "', argument " "1"" of type '" "CalibratedModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &((CalibratedModel const *)arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Constraint > *smartresult = *result ? new ext::shared_ptr<  Constraint >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel const > tempshared1 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_endCriteria" "', argument " "1"" of type '" "CalibratedModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((CalibratedModel const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_problemValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel const > tempshared1 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_problemValues" "', argument " "1"" of type '" "CalibratedModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &((CalibratedModel const *)arg1)->problemValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModel_functionEvaluation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel const > tempshared1 ;
  ext::shared_ptr< CalibratedModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModel_functionEvaluation" "', argument " "1"" of type '" "CalibratedModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Integer)((CalibratedModel const *)arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibratedModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CalibratedModel *arg1 = (CalibratedModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  ext::shared_ptr< CalibratedModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibratedModel" "', argument " "1"" of type '" "CalibratedModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CalibratedModel > * >(argp1);
      arg1 = const_cast< CalibratedModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibratedModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_TermStructureConsistentModel_termStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructureConsistentModel *arg1 = (TermStructureConsistentModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructureConsistentModel const > tempshared1 ;
  ext::shared_ptr< TermStructureConsistentModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructureConsistentModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TermStructureConsistentModel_termStructure" "', argument " "1"" of type '" "TermStructureConsistentModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TermStructureConsistentModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TermStructureConsistentModel > * >(argp1);
      arg1 = const_cast< TermStructureConsistentModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TermStructureConsistentModel > * >(argp1);
      arg1 = const_cast< TermStructureConsistentModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((TermStructureConsistentModel const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TermStructureConsistentModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TermStructureConsistentModel *arg1 = (TermStructureConsistentModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TermStructureConsistentModel > tempshared1 ;
  ext::shared_ptr< TermStructureConsistentModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TermStructureConsistentModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TermStructureConsistentModel" "', argument " "1"" of type '" "TermStructureConsistentModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TermStructureConsistentModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TermStructureConsistentModel > * >(argp1);
      arg1 = const_cast< TermStructureConsistentModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TermStructureConsistentModel > * >(argp1);
      arg1 = const_cast< TermStructureConsistentModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TermStructureConsistentModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TermStructureConsistentModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CalibratedModelHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CalibratedModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  Handle< CalibratedModel > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalibratedModelHandle" "', argument " "1"" of type '" "ext::shared_ptr< CalibratedModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< CalibratedModel > *)new Handle< CalibratedModel >((ext::shared_ptr< CalibratedModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_CalibratedModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibratedModelHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< CalibratedModel > *)new Handle< CalibratedModel >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_CalibratedModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibratedModelHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CalibratedModelHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CalibratedModelHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalibratedModelHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CalibratedModelHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< CalibratedModel >::Handle(ext::shared_ptr< CalibratedModel > const &)\n"
    "    Handle< CalibratedModel >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CalibratedModel > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle___deref__" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CalibratedModel > *smartresult = result ? new ext::shared_ptr<  CalibratedModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CalibratedModel > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_currentLink" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CalibratedModel > *smartresult = result ? new ext::shared_ptr<  CalibratedModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle___nonzero__" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_CalibratedModel_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle___bool__" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_CalibratedModel_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_asObservable" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = Handle_Sl_CalibratedModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibratedModelHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibratedModelHandle" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_params" "', argument " "1"" of type '" "Handle< CalibratedModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_calibrate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_calibrate" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CalibratedModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CalibratedModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CalibratedModelHandle_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(std::vector< bool,std::allocator< bool > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_calibrate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_calibrate" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CalibratedModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CalibratedModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_calibrate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_calibrate" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CalibratedModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_calibrate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_calibrate" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_calibrate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibratedModelHandle_calibrate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalibratedModelHandle_calibrate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_CalibratedModelHandle_calibrate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_CalibratedModelHandle_calibrate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector<bool,std::allocator< bool > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CalibratedModelHandle_calibrate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibratedModelHandle_calibrate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &,std::vector< bool,std::allocator< bool > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_setParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibratedModelHandle_setParams", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_setParams" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModelHandle_setParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_setParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibratedModelHandle_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_value" "', argument " "1"" of type '" "Handle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibratedModelHandle_value" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_value" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibratedModelHandle_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibratedModelHandle_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_constraint" "', argument " "1"" of type '" "Handle< CalibratedModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &(*arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Constraint > *smartresult = *result ? new ext::shared_ptr<  Constraint >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_endCriteria" "', argument " "1"" of type '" "Handle< CalibratedModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (EndCriteria::Type)(*arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_problemValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_problemValues" "', argument " "1"" of type '" "Handle< CalibratedModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (Array *) &(*arg1)->problemValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibratedModelHandle_functionEvaluation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CalibratedModel > *arg1 = (Handle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibratedModelHandle_functionEvaluation" "', argument " "1"" of type '" "Handle< CalibratedModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CalibratedModel > * >(argp1);
  {
    try {
      result = (Integer)(*arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibratedModelHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_CalibratedModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CalibratedModelHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableCalibratedModelHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CalibratedModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared1 ;
  RelinkableHandle< CalibratedModel > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableCalibratedModelHandle" "', argument " "1"" of type '" "ext::shared_ptr< CalibratedModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< CalibratedModel > *)new RelinkableHandle< CalibratedModel >((ext::shared_ptr< CalibratedModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableCalibratedModelHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< CalibratedModel > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< CalibratedModel > *)new RelinkableHandle< CalibratedModel >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableCalibratedModelHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableCalibratedModelHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableCalibratedModelHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableCalibratedModelHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableCalibratedModelHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< CalibratedModel >::RelinkableHandle(ext::shared_ptr< CalibratedModel > const &)\n"
    "    RelinkableHandle< CalibratedModel >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableCalibratedModelHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< CalibratedModel > *arg1 = (RelinkableHandle< CalibratedModel > *) 0 ;
  ext::shared_ptr< CalibratedModel > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< CalibratedModel > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableCalibratedModelHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableCalibratedModelHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< CalibratedModel > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CalibratedModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableCalibratedModelHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< CalibratedModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< CalibratedModel > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< CalibratedModel > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableCalibratedModelHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< CalibratedModel > *arg1 = (RelinkableHandle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableCalibratedModelHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< CalibratedModel > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_CalibratedModel_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableCalibratedModelHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< CalibratedModel > *arg1 = (RelinkableHandle< CalibratedModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableCalibratedModelHandle" "', argument " "1"" of type '" "RelinkableHandle< CalibratedModel > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< CalibratedModel > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableCalibratedModelHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_CalibratedModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableCalibratedModelHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Parameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Parameter", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Parameter *)new Parameter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Parameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_params" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    try {
      result = (Array *) &((Parameter const *)arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_setParam(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  Size arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_setParam", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_setParam" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter_setParam" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Parameter_setParam" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->setParam(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_testParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter_testParams", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_testParams" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parameter_testParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parameter_testParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (bool)((Parameter const *)arg1)->testParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_size" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    try {
      result = ((Parameter const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Parameter___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter___call__" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parameter___call__" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((Parameter const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parameter_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Constraint *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parameter_constraint" "', argument " "1"" of type '" "Parameter const *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    try {
      result = (Constraint *) &((Parameter const *)arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr< const Constraint > *smartresult = new ext::shared_ptr< const Constraint >(result SWIG_NO_NULL_DELETER_0);
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Parameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Parameter *arg1 = (Parameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Parameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Parameter" "', argument " "1"" of type '" "Parameter *""'"); 
  }
  arg1 = reinterpret_cast< Parameter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Parameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Parameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Parameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConstantParameter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Constraint *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Constraint const > tempshared1 ;
  ConstantParameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantParameter" "', argument " "1"" of type '" "Constraint const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantParameter" "', argument " "1"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp1);
      arg1 = const_cast< Constraint * >(tempshared1.get());
    } else {
      arg1 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp1)->get());
    }
  }
  {
    try {
      result = (ConstantParameter *)new ConstantParameter((Constraint const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantParameter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Constraint *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Constraint const > tempshared2 ;
  ConstantParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantParameter" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantParameter" "', argument " "2"" of type '" "Constraint const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantParameter" "', argument " "2"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2);
      arg2 = const_cast< Constraint * >(tempshared2.get());
    } else {
      arg2 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2)->get());
    }
  }
  {
    try {
      result = (ConstantParameter *)new ConstantParameter(arg1,(Constraint const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstantParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConstantParameter__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ConstantParameter__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstantParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConstantParameter::ConstantParameter(Constraint const &)\n"
    "    ConstantParameter::ConstantParameter(Real,Constraint const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConstantParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantParameter *arg1 = (ConstantParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstantParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantParameter" "', argument " "1"" of type '" "ConstantParameter *""'"); 
  }
  arg1 = reinterpret_cast< ConstantParameter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstantParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ConstantParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstantParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NullParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NullParameter *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NullParameter", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (NullParameter *)new NullParameter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NullParameter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NullParameter *arg1 = (NullParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NullParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullParameter" "', argument " "1"" of type '" "NullParameter *""'"); 
  }
  arg1 = reinterpret_cast< NullParameter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_NullParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NullParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseConstantParameter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Constraint *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Constraint const > tempshared2 ;
  PiecewiseConstantParameter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConstantParameter" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConstantParameter" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConstantParameter" "', argument " "2"" of type '" "Constraint const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConstantParameter" "', argument " "2"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2);
      arg2 = const_cast< Constraint * >(tempshared2.get());
    } else {
      arg2 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp2)->get());
    }
  }
  {
    try {
      result = (PiecewiseConstantParameter *)new PiecewiseConstantParameter((std::vector< Time,std::allocator< Time > > const &)*arg1,(Constraint const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewiseConstantParameter, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConstantParameter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PiecewiseConstantParameter *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConstantParameter" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConstantParameter" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (PiecewiseConstantParameter *)new PiecewiseConstantParameter((std::vector< Time,std::allocator< Time > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PiecewiseConstantParameter, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConstantParameter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseConstantParameter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PiecewiseConstantParameter__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PiecewiseConstantParameter__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseConstantParameter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseConstantParameter::PiecewiseConstantParameter(std::vector< Time,std::allocator< Time > > const &,Constraint const &)\n"
    "    PiecewiseConstantParameter::PiecewiseConstantParameter(std::vector< Time,std::allocator< Time > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseConstantParameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantParameter *arg1 = (PiecewiseConstantParameter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PiecewiseConstantParameter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseConstantParameter" "', argument " "1"" of type '" "PiecewiseConstantParameter *""'"); 
  }
  arg1 = reinterpret_cast< PiecewiseConstantParameter * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseConstantParameter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PiecewiseConstantParameter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseConstantParameter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Payoff___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Payoff *arg1 = (Payoff *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff const > tempshared1 ;
  ext::shared_ptr< Payoff const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Payoff___call__", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Payoff___call__" "', argument " "1"" of type '" "Payoff const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Payoff > * >(argp1);
      arg1 = const_cast< Payoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Payoff > * >(argp1);
      arg1 = const_cast< Payoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Payoff___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((Payoff const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Payoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Payoff *arg1 = (Payoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff > tempshared1 ;
  ext::shared_ptr< Payoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Payoff" "', argument " "1"" of type '" "Payoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Payoff > * >(argp1);
      arg1 = const_cast< Payoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Payoff > * >(argp1);
      arg1 = const_cast< Payoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Payoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Payoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Option_payoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option *arg1 = (Option *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Option > tempshared1 ;
  ext::shared_ptr< Option > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Payoff > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Option_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Option_payoff" "', argument " "1"" of type '" "Option *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      arg1 = const_cast< Option * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      arg1 = const_cast< Option * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->payoff();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Payoff > *smartresult = result ? new ext::shared_ptr<  Payoff >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Payoff_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Option_exercise(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option *arg1 = (Option *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Option > tempshared1 ;
  ext::shared_ptr< Option > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Exercise > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Option_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Option_exercise" "', argument " "1"" of type '" "Option *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      arg1 = const_cast< Option * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      arg1 = const_cast< Option * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->exercise();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Exercise > *smartresult = result ? new ext::shared_ptr<  Exercise >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Exercise_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Option(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option *arg1 = (Option *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Option > tempshared1 ;
  ext::shared_ptr< Option > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Option_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Option" "', argument " "1"" of type '" "Option *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      arg1 = const_cast< Option * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Option > * >(argp1);
      arg1 = const_cast< Option * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Option_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Option_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_TypePayoff_optionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TypePayoff *arg1 = (TypePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TypePayoff > tempshared1 ;
  ext::shared_ptr< TypePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Option::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TypePayoff_optionType" "', argument " "1"" of type '" "TypePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TypePayoff > * >(argp1);
      arg1 = const_cast< TypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TypePayoff > * >(argp1);
      arg1 = const_cast< TypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Option::Type)(arg1)->optionType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TypePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TypePayoff *arg1 = (TypePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TypePayoff > tempshared1 ;
  ext::shared_ptr< TypePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TypePayoff" "', argument " "1"" of type '" "TypePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TypePayoff > * >(argp1);
      arg1 = const_cast< TypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TypePayoff > * >(argp1);
      arg1 = const_cast< TypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TypePayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TypePayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FloatingTypePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  FloatingTypePayoff *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatingTypePayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  {
    try {
      result = (FloatingTypePayoff *)new FloatingTypePayoff(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatingTypePayoff > *smartresult = result ? new ext::shared_ptr<  FloatingTypePayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingTypePayoff___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FloatingTypePayoff *arg1 = (FloatingTypePayoff *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingTypePayoff const > tempshared1 ;
  ext::shared_ptr< FloatingTypePayoff const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingTypePayoff___call__" "', argument " "1"" of type '" "FloatingTypePayoff const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingTypePayoff > * >(argp1);
      arg1 = const_cast< FloatingTypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingTypePayoff > * >(argp1);
      arg1 = const_cast< FloatingTypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatingTypePayoff___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatingTypePayoff___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FloatingTypePayoff const *)arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingTypePayoff___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FloatingTypePayoff *arg1 = (FloatingTypePayoff *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingTypePayoff const > tempshared1 ;
  ext::shared_ptr< FloatingTypePayoff const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatingTypePayoff___call__" "', argument " "1"" of type '" "FloatingTypePayoff const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FloatingTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FloatingTypePayoff > * >(argp1);
      arg1 = const_cast< FloatingTypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FloatingTypePayoff > * >(argp1);
      arg1 = const_cast< FloatingTypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatingTypePayoff___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((FloatingTypePayoff const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatingTypePayoff___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FloatingTypePayoff___call__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FloatingTypePayoff___call____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FloatingTypePayoff___call____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FloatingTypePayoff___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FloatingTypePayoff::operator ()(Real,Real) const\n"
    "    FloatingTypePayoff::operator ()(Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FloatingTypePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingTypePayoff *arg1 = (FloatingTypePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingTypePayoff > tempshared1 ;
  ext::shared_ptr< FloatingTypePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatingTypePayoff" "', argument " "1"" of type '" "FloatingTypePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatingTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatingTypePayoff > * >(argp1);
      arg1 = const_cast< FloatingTypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatingTypePayoff > * >(argp1);
      arg1 = const_cast< FloatingTypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloatingTypePayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FloatingTypePayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FloatingTypePayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StrikedTypePayoff_strike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrikedTypePayoff *arg1 = (StrikedTypePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  ext::shared_ptr< StrikedTypePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrikedTypePayoff_strike" "', argument " "1"" of type '" "StrikedTypePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrikedTypePayoff > * >(argp1);
      arg1 = const_cast< StrikedTypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrikedTypePayoff > * >(argp1);
      arg1 = const_cast< StrikedTypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->strike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StrikedTypePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrikedTypePayoff *arg1 = (StrikedTypePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  ext::shared_ptr< StrikedTypePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikedTypePayoff" "', argument " "1"" of type '" "StrikedTypePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrikedTypePayoff > * >(argp1);
      arg1 = const_cast< StrikedTypePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrikedTypePayoff > * >(argp1);
      arg1 = const_cast< StrikedTypePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrikedTypePayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeltaVolQuote__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Handle< Quote > *arg2 = 0 ;
  Time arg3 ;
  DeltaVolQuote::DeltaType arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  DeltaVolQuote *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DeltaVolQuote" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DeltaVolQuote" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeltaVolQuote" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DeltaVolQuote" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DeltaVolQuote" "', argument " "4"" of type '" "DeltaVolQuote::DeltaType""'");
  } 
  arg4 = static_cast< DeltaVolQuote::DeltaType >(val4);
  {
    try {
      result = (DeltaVolQuote *)new DeltaVolQuote(arg1,(Handle< Quote > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DeltaVolQuote > *smartresult = result ? new ext::shared_ptr<  DeltaVolQuote >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeltaVolQuote__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  DeltaVolQuote::DeltaType arg2 ;
  Time arg3 ;
  DeltaVolQuote::AtmType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  DeltaVolQuote *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeltaVolQuote" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeltaVolQuote" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DeltaVolQuote" "', argument " "2"" of type '" "DeltaVolQuote::DeltaType""'");
  } 
  arg2 = static_cast< DeltaVolQuote::DeltaType >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DeltaVolQuote" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DeltaVolQuote" "', argument " "4"" of type '" "DeltaVolQuote::AtmType""'");
  } 
  arg4 = static_cast< DeltaVolQuote::AtmType >(val4);
  {
    try {
      result = (DeltaVolQuote *)new DeltaVolQuote((Handle< Quote > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DeltaVolQuote > *smartresult = result ? new ext::shared_ptr<  DeltaVolQuote >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeltaVolQuote(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DeltaVolQuote", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_DeltaVolQuote__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_DeltaVolQuote__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DeltaVolQuote'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DeltaVolQuote::DeltaVolQuote(Real,Handle< Quote > const &,Time,DeltaVolQuote::DeltaType)\n"
    "    DeltaVolQuote::DeltaVolQuote(Handle< Quote > const &,DeltaVolQuote::DeltaType,Time,DeltaVolQuote::AtmType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuote_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote const > tempshared1 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuote_delta" "', argument " "1"" of type '" "DeltaVolQuote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((DeltaVolQuote const *)arg1)->delta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuote_maturity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote const > tempshared1 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuote_maturity" "', argument " "1"" of type '" "DeltaVolQuote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Time)((DeltaVolQuote const *)arg1)->maturity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuote_atmType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote const > tempshared1 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DeltaVolQuote::AtmType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuote_atmType" "', argument " "1"" of type '" "DeltaVolQuote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DeltaVolQuote::AtmType)((DeltaVolQuote const *)arg1)->atmType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuote_deltaType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote const > tempshared1 ;
  ext::shared_ptr< DeltaVolQuote const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DeltaVolQuote::DeltaType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuote_deltaType" "', argument " "1"" of type '" "DeltaVolQuote const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DeltaVolQuote::DeltaType)((DeltaVolQuote const *)arg1)->deltaType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DeltaVolQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DeltaVolQuote *arg1 = (DeltaVolQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempshared1 ;
  ext::shared_ptr< DeltaVolQuote > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeltaVolQuote" "', argument " "1"" of type '" "DeltaVolQuote *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DeltaVolQuote > * >(argp1);
      arg1 = const_cast< DeltaVolQuote * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeltaVolQuote_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DeltaVolQuote_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DeltaVolQuoteHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< DeltaVolQuote > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempshared1 ;
  Handle< DeltaVolQuote > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeltaVolQuoteHandle" "', argument " "1"" of type '" "ext::shared_ptr< DeltaVolQuote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< DeltaVolQuote > *)new Handle< DeltaVolQuote >((ext::shared_ptr< DeltaVolQuote > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeltaVolQuoteHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< DeltaVolQuote > *)new Handle< DeltaVolQuote >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeltaVolQuoteHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DeltaVolQuoteHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DeltaVolQuoteHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeltaVolQuoteHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DeltaVolQuoteHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< DeltaVolQuote >::Handle(ext::shared_ptr< DeltaVolQuote > const &)\n"
    "    Handle< DeltaVolQuote >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< DeltaVolQuote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle___deref__" "', argument " "1"" of type '" "Handle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DeltaVolQuote > *smartresult = result ? new ext::shared_ptr<  DeltaVolQuote >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< DeltaVolQuote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_currentLink" "', argument " "1"" of type '" "Handle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DeltaVolQuote > *smartresult = result ? new ext::shared_ptr<  DeltaVolQuote >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle___nonzero__" "', argument " "1"" of type '" "Handle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_DeltaVolQuote_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle___bool__" "', argument " "1"" of type '" "Handle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_DeltaVolQuote_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_asObservable" "', argument " "1"" of type '" "Handle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = Handle_Sl_DeltaVolQuote_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DeltaVolQuoteHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeltaVolQuoteHandle" "', argument " "1"" of type '" "Handle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_delta" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->delta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_maturity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_maturity" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maturity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_atmType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DeltaVolQuote::AtmType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_atmType" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (DeltaVolQuote::AtmType)(*arg1)->atmType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_deltaType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DeltaVolQuote::DeltaType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_deltaType" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (DeltaVolQuote::DeltaType)(*arg1)->deltaType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_value" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->value();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DeltaVolQuoteHandle_isValid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = (Handle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaVolQuoteHandle_isValid" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->isValid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeltaVolQuoteHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DeltaVolQuoteHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableDeltaVolQuoteHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< DeltaVolQuote > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempshared1 ;
  RelinkableHandle< DeltaVolQuote > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableDeltaVolQuoteHandle" "', argument " "1"" of type '" "ext::shared_ptr< DeltaVolQuote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< DeltaVolQuote > *)new RelinkableHandle< DeltaVolQuote >((ext::shared_ptr< DeltaVolQuote > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableDeltaVolQuoteHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< DeltaVolQuote > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< DeltaVolQuote > *)new RelinkableHandle< DeltaVolQuote >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableDeltaVolQuoteHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableDeltaVolQuoteHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableDeltaVolQuoteHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableDeltaVolQuoteHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableDeltaVolQuoteHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< DeltaVolQuote >::RelinkableHandle(ext::shared_ptr< DeltaVolQuote > const &)\n"
    "    RelinkableHandle< DeltaVolQuote >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableDeltaVolQuoteHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< DeltaVolQuote > *arg1 = (RelinkableHandle< DeltaVolQuote > *) 0 ;
  ext::shared_ptr< DeltaVolQuote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< DeltaVolQuote > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableDeltaVolQuoteHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableDeltaVolQuoteHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< DeltaVolQuote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_DeltaVolQuote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableDeltaVolQuoteHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< DeltaVolQuote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< DeltaVolQuote > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< DeltaVolQuote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableDeltaVolQuoteHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< DeltaVolQuote > *arg1 = (RelinkableHandle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableDeltaVolQuoteHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< DeltaVolQuote > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_DeltaVolQuote_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableDeltaVolQuoteHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< DeltaVolQuote > *arg1 = (RelinkableHandle< DeltaVolQuote > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableDeltaVolQuoteHandle" "', argument " "1"" of type '" "RelinkableHandle< DeltaVolQuote > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< DeltaVolQuote > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableDeltaVolQuoteHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_DeltaVolQuote_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableDeltaVolQuoteHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_OneAssetOption_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_delta" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->delta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_deltaForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_deltaForward" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->deltaForward();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_elasticity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_elasticity" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->elasticity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_gamma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_gamma" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->gamma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_theta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_theta" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->theta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_thetaPerDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_thetaPerDay" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->thetaPerDay();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_vega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_vega" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->vega();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_rho" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_dividendRho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_dividendRho" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->dividendRho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_strikeSensitivity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_strikeSensitivity" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->strikeSensitivity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneAssetOption_itmCashProbability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption const > tempshared1 ;
  ext::shared_ptr< OneAssetOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneAssetOption_itmCashProbability" "', argument " "1"" of type '" "OneAssetOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OneAssetOption const *)arg1)->itmCashProbability();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OneAssetOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneAssetOption *arg1 = (OneAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneAssetOption > tempshared1 ;
  ext::shared_ptr< OneAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OneAssetOption" "', argument " "1"" of type '" "OneAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OneAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OneAssetOption > * >(argp1);
      arg1 = const_cast< OneAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OneAssetOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OneAssetOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_VanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  PyObject *swig_obj[2] ;
  VanillaOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VanillaOption", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VanillaOption" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VanillaOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (VanillaOption *)new VanillaOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaOption > *smartresult = result ? new ext::shared_ptr<  VanillaOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "VanillaOption_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "VanillaOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "VanillaOption_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Volatility result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "VanillaOption_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "VanillaOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "VanillaOption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "VanillaOption_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "VanillaOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "VanillaOption_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "VanillaOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_impliedVolatility" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VanillaOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaOption_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "VanillaOption_impliedVolatility", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VanillaOption_impliedVolatility__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VanillaOption_impliedVolatility__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VanillaOption_impliedVolatility__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_VanillaOption_impliedVolatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_VanillaOption_impliedVolatility__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_VanillaOption_impliedVolatility__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_VanillaOption_impliedVolatility__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_VanillaOption_impliedVolatility__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_VanillaOption_impliedVolatility__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_VanillaOption_impliedVolatility__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VanillaOption_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Volatility,Volatility)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Volatility)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real,Size,Volatility,Volatility)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real,Size,Volatility)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real,Size)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real)\n"
    "    VanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VanillaOption_priceCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SampledCurve result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaOption_priceCurve" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = VanillaOption_priceCurve(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new SampledCurve(result)), SWIGTYPE_p_SampledCurve, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaOption *arg1 = (VanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared1 ;
  ext::shared_ptr< VanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VanillaOption" "', argument " "1"" of type '" "VanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaOption > * >(argp1);
      arg1 = const_cast< VanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VanillaOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VanillaOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CalibrationPair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)new std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationPair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VanillaOption > arg1 ;
  ext::shared_ptr< Quote > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalibrationPair" "', argument " "1"" of type '" "ext::shared_ptr< VanillaOption >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< VanillaOption > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< VanillaOption > * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CalibrationPair" "', argument " "2"" of type '" "ext::shared_ptr< Quote >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< Quote > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
  }
  {
    try {
      result = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)new std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationPair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalibrationPair" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalibrationPair" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)new std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >((std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationPair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CalibrationPair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CalibrationPair__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalibrationPair__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CalibrationPair__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CalibrationPair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >::pair()\n"
    "    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >::pair(ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote >)\n"
    "    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >::pair(std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationPair_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< VanillaOption > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< VanillaOption > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationPair_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationPair_first_set" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationPair_first_set" "', argument " "2"" of type '" "ext::shared_ptr< VanillaOption > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< VanillaOption > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< VanillaOption > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< VanillaOption > * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationPair_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< VanillaOption > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationPair_first_get" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > * >(argp1);
  result = (ext::shared_ptr< VanillaOption > *) & ((arg1)->first);
  {
    ext::shared_ptr<  VanillaOption > *smartresult = *result ? new ext::shared_ptr<  VanillaOption >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaOption_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationPair_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Quote > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationPair_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationPair_second_set" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationPair_second_set" "', argument " "2"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationPair_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Quote > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationPair_second_get" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > * >(argp1);
  result = (ext::shared_ptr< Quote > *) & ((arg1)->second);
  {
    ext::shared_ptr<  Quote > *smartresult = *result ? new ext::shared_ptr<  Quote >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Quote_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibrationPair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *arg1 = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibrationPair" "', argument " "1"" of type '" "std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibrationPair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CalibrationPair_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CalibrationSet_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_iterator" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____nonzero__((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___bool__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____bool__((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___len__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____len__((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationSet___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationSet___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg3 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationSet___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *ptr = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibrationSet___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CalibrationSet___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalibrationSet___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__setslice__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__setslice__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationSet___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *)std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *ptr = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationSet___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalibrationSet___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalibrationSet___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__delitem__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *) &std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____getitem____SWIG_1((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalibrationSet___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalibrationSet___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__getitem__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type >(val2);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationSet___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CalibrationSet___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationSet___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationSet___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > const &)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::__setitem__(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_pop" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_append" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationSet_append" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_append" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__append(arg1,(std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *ptr = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalibrationSet" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalibrationSet" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_empty" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_size" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_swap" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationSet_swap" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_swap" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_begin" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_end" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_rend" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_clear" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationSet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalibrationSet" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_resize" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet_resize" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_erase" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_erase" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_erase" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_erase" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_erase" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_erase" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_erase" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_erase" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_CalibrationSet_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_CalibrationSet_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::erase(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::erase(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CalibrationSet__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg1 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalibrationSet" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val1);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CalibrationSet" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalibrationSet" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *)new std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(arg1,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalibrationSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CalibrationSet", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CalibrationSet__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CalibrationSet__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalibrationSet__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CalibrationSet__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CalibrationSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::vector()\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::vector(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const &)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::vector(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::vector(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_push_back" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalibrationSet_push_back" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_push_back" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_front" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *) &((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_back" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *) &((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_assign" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet_assign" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationSet_assign" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_assign" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_resize" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet_resize" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationSet_resize" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_resize" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CalibrationSet_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationSet_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::resize(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::resize(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_insert" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_insert" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_insert" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CalibrationSet_insert" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_insert" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator arg2 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg3 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_insert" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_insert" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CalibrationSet_insert" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CalibrationSet_insert" "', argument " "3"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val3);
  {
    std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *ptr = (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CalibrationSet_insert" "', argument " "4"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalibrationSet_insert" "', argument " "4"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_ext_shared_ptr_Sl_VanillaOption_Sg__Sc_ext_shared_ptr_Sl_Quote_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CalibrationSet_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CalibrationSet_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >,std::allocator< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CalibrationSet_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CalibrationSet_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::insert(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)\n"
    "    std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::insert(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type,std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CalibrationSet_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_reserve" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CalibrationSet_reserve" "', argument " "2"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CalibrationSet_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalibrationSet_capacity" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CalibrationSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *arg1 = (std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalibrationSet" "', argument " "1"" of type '" "std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalibrationSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_std__allocatorT_std__pairT_ext__shared_ptrT_VanillaOption_t_ext__shared_ptrT_Quote_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CalibrationSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EuropeanOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  PyObject *swig_obj[2] ;
  EuropeanOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EuropeanOption", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EuropeanOption" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EuropeanOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (EuropeanOption *)new EuropeanOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EuropeanOption > *smartresult = result ? new ext::shared_ptr<  EuropeanOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EuropeanOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EuropeanOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EuropeanOption *arg1 = (EuropeanOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EuropeanOption > tempshared1 ;
  ext::shared_ptr< EuropeanOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EuropeanOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EuropeanOption" "', argument " "1"" of type '" "EuropeanOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EuropeanOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EuropeanOption > * >(argp1);
      arg1 = const_cast< EuropeanOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EuropeanOption > * >(argp1);
      arg1 = const_cast< EuropeanOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EuropeanOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EuropeanOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EuropeanOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date arg2 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< Exercise > tempshared4 ;
  PyObject *swig_obj[4] ;
  ForwardVanillaOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ForwardVanillaOption", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ForwardVanillaOption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardVanillaOption" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardVanillaOption" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ForwardVanillaOption" "', argument " "3"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ForwardVanillaOption" "', argument " "4"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (ForwardVanillaOption *)new ForwardVanillaOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::shared_ptr< Exercise > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardVanillaOption > *smartresult = result ? new ext::shared_ptr<  ForwardVanillaOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardVanillaOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardVanillaOption *arg1 = (ForwardVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardVanillaOption > tempshared1 ;
  ext::shared_ptr< ForwardVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardVanillaOption" "', argument " "1"" of type '" "ForwardVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ForwardVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ForwardVanillaOption > * >(argp1);
      arg1 = const_cast< ForwardVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ForwardVanillaOption > * >(argp1);
      arg1 = const_cast< ForwardVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardVanillaOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ForwardVanillaOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardVanillaOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  PyObject *swig_obj[2] ;
  QuantoVanillaOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoVanillaOption", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantoVanillaOption" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuantoVanillaOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (QuantoVanillaOption *)new QuantoVanillaOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoVanillaOption > *smartresult = result ? new ext::shared_ptr<  QuantoVanillaOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuantoVanillaOption_qvega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoVanillaOption > tempshared1 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantoVanillaOption_qvega" "', argument " "1"" of type '" "QuantoVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->qvega();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuantoVanillaOption_qrho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoVanillaOption > tempshared1 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantoVanillaOption_qrho" "', argument " "1"" of type '" "QuantoVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->qrho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuantoVanillaOption_qlambda(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoVanillaOption > tempshared1 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantoVanillaOption_qlambda" "', argument " "1"" of type '" "QuantoVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->qlambda();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoVanillaOption *arg1 = (QuantoVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoVanillaOption > tempshared1 ;
  ext::shared_ptr< QuantoVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoVanillaOption" "', argument " "1"" of type '" "QuantoVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoVanillaOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoVanillaOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoVanillaOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoForwardVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date arg2 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< Exercise > tempshared4 ;
  PyObject *swig_obj[4] ;
  QuantoForwardVanillaOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoForwardVanillaOption", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuantoForwardVanillaOption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuantoForwardVanillaOption" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoForwardVanillaOption" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_QuantoForwardVanillaOption" "', argument " "3"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_QuantoForwardVanillaOption" "', argument " "4"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (QuantoForwardVanillaOption *)new QuantoForwardVanillaOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::shared_ptr< Exercise > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoForwardVanillaOption > *smartresult = result ? new ext::shared_ptr<  QuantoForwardVanillaOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoForwardVanillaOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoForwardVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoForwardVanillaOption *arg1 = (QuantoForwardVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoForwardVanillaOption > tempshared1 ;
  ext::shared_ptr< QuantoForwardVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoForwardVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoForwardVanillaOption" "', argument " "1"" of type '" "QuantoForwardVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoForwardVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoForwardVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoForwardVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoForwardVanillaOption > * >(argp1);
      arg1 = const_cast< QuantoForwardVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoForwardVanillaOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoForwardVanillaOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoForwardVanillaOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_MultiAssetOption_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiAssetOption_delta" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->delta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiAssetOption_gamma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiAssetOption_gamma" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->gamma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiAssetOption_theta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiAssetOption_theta" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->theta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiAssetOption_vega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiAssetOption_vega" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->vega();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiAssetOption_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiAssetOption_rho" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiAssetOption_dividendRho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiAssetOption_dividendRho" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->dividendRho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MultiAssetOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiAssetOption *arg1 = (MultiAssetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiAssetOption > tempshared1 ;
  ext::shared_ptr< MultiAssetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiAssetOption" "', argument " "1"" of type '" "MultiAssetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiAssetOption > * >(argp1);
      arg1 = const_cast< MultiAssetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultiAssetOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MultiAssetOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AnalyticEuropeanEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  AnalyticEuropeanEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticEuropeanEngine *)new AnalyticEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticEuropeanEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  AnalyticEuropeanEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticEuropeanEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticEuropeanEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (AnalyticEuropeanEngine *)new AnalyticEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticEuropeanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticEuropeanEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticEuropeanEngine__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AnalyticEuropeanEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticEuropeanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticEuropeanEngine::AnalyticEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    AnalyticEuropeanEngine::AnalyticEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticEuropeanEngine *arg1 = (AnalyticEuropeanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticEuropeanEngine > tempshared1 ;
  ext::shared_ptr< AnalyticEuropeanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticEuropeanEngine" "', argument " "1"" of type '" "AnalyticEuropeanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticEuropeanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticEuropeanEngine > * >(argp1);
      arg1 = const_cast< AnalyticEuropeanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticEuropeanEngine > * >(argp1);
      arg1 = const_cast< AnalyticEuropeanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  HestonModel *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonModel" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (HestonModel *)new HestonModel((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonModel > *smartresult = result ? new ext::shared_ptr<  HestonModel >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModel_theta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModel *arg1 = (HestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel const > tempshared1 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModel_theta" "', argument " "1"" of type '" "HestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((HestonModel const *)arg1)->theta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModel_kappa(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModel *arg1 = (HestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel const > tempshared1 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModel_kappa" "', argument " "1"" of type '" "HestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((HestonModel const *)arg1)->kappa();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModel_sigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModel *arg1 = (HestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel const > tempshared1 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModel_sigma" "', argument " "1"" of type '" "HestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((HestonModel const *)arg1)->sigma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModel_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModel *arg1 = (HestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel const > tempshared1 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModel_rho" "', argument " "1"" of type '" "HestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((HestonModel const *)arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModel_v0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModel *arg1 = (HestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel const > tempshared1 ;
  ext::shared_ptr< HestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModel_v0" "', argument " "1"" of type '" "HestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((HestonModel const *)arg1)->v0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModel *arg1 = (HestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  ext::shared_ptr< HestonModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonModel" "', argument " "1"" of type '" "HestonModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonModel > * >(argp1);
      arg1 = const_cast< HestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonModelHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  Handle< HestonModel > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonModelHandle" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< HestonModel > *)new Handle< HestonModel >((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_HestonModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonModelHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< HestonModel > *)new Handle< HestonModel >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_HestonModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonModelHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonModelHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_HestonModelHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HestonModelHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonModelHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< HestonModel >::Handle(ext::shared_ptr< HestonModel > const &)\n"
    "    Handle< HestonModel >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< HestonModel > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle___deref__" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonModel > *smartresult = result ? new ext::shared_ptr<  HestonModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< HestonModel > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_currentLink" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonModel > *smartresult = result ? new ext::shared_ptr<  HestonModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle___nonzero__" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_HestonModel_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle___bool__" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_HestonModel_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_asObservable" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = Handle_Sl_HestonModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonModelHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonModelHandle" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_theta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_theta" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->theta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_kappa(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_kappa" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->kappa();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_sigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_sigma" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->sigma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_rho" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->rho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_v0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_v0" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->v0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_params" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_calibrate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_calibrate" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HestonModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "HestonModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "HestonModelHandle_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(std::vector< bool,std::allocator< bool > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_calibrate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_calibrate" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HestonModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "HestonModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_calibrate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_calibrate" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HestonModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_calibrate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_calibrate" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_calibrate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HestonModelHandle_calibrate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HestonModelHandle_calibrate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_HestonModelHandle_calibrate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_HestonModelHandle_calibrate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector<bool,std::allocator< bool > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_HestonModelHandle_calibrate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HestonModelHandle_calibrate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &,std::vector< bool,std::allocator< bool > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_setParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "HestonModelHandle_setParams", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_setParams" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HestonModelHandle_setParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_setParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "HestonModelHandle_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_value" "', argument " "1"" of type '" "Handle< HestonModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HestonModelHandle_value" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_value" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HestonModelHandle_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HestonModelHandle_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_constraint" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &(*arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Constraint > *smartresult = *result ? new ext::shared_ptr<  Constraint >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_endCriteria" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (EndCriteria::Type)(*arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_problemValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_problemValues" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Array *) &(*arg1)->problemValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonModelHandle_functionEvaluation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< HestonModel > *arg1 = (Handle< HestonModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_HestonModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonModelHandle_functionEvaluation" "', argument " "1"" of type '" "Handle< HestonModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< HestonModel > * >(argp1);
  {
    try {
      result = (Integer)(*arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonModelHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_HestonModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonModelHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseTimeDependentHestonModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Real arg4 ;
  Parameter *arg5 = 0 ;
  Parameter *arg6 = 0 ;
  Parameter *arg7 = 0 ;
  Parameter *arg8 = 0 ;
  TimeGrid *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 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 *swig_obj[9] ;
  PiecewiseTimeDependentHestonModel *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PiecewiseTimeDependentHestonModel", 9, 9, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Parameter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "5"" of type '" "Parameter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "5"" of type '" "Parameter const &""'"); 
  }
  arg5 = reinterpret_cast< Parameter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Parameter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "6"" of type '" "Parameter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "6"" of type '" "Parameter const &""'"); 
  }
  arg6 = reinterpret_cast< Parameter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Parameter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "7"" of type '" "Parameter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "7"" of type '" "Parameter const &""'"); 
  }
  arg7 = reinterpret_cast< Parameter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Parameter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "8"" of type '" "Parameter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "8"" of type '" "Parameter const &""'"); 
  }
  arg8 = reinterpret_cast< Parameter * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "9"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseTimeDependentHestonModel" "', argument " "9"" of type '" "TimeGrid const &""'"); 
  }
  arg9 = reinterpret_cast< TimeGrid * >(argp9);
  {
    try {
      result = (PiecewiseTimeDependentHestonModel *)new PiecewiseTimeDependentHestonModel((Handle< YieldTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< Quote > const &)*arg3,arg4,(Parameter const &)*arg5,(Parameter const &)*arg6,(Parameter const &)*arg7,(Parameter const &)*arg8,(TimeGrid const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseTimeDependentHestonModel > *smartresult = result ? new ext::shared_ptr<  PiecewiseTimeDependentHestonModel >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_theta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "PiecewiseTimeDependentHestonModel_theta", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_theta" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewiseTimeDependentHestonModel_theta" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->theta(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_kappa(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "PiecewiseTimeDependentHestonModel_kappa", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_kappa" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewiseTimeDependentHestonModel_kappa" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->kappa(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_sigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "PiecewiseTimeDependentHestonModel_sigma", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_sigma" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewiseTimeDependentHestonModel_sigma" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->sigma(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "PiecewiseTimeDependentHestonModel_rho", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_rho" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewiseTimeDependentHestonModel_rho" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->rho(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_v0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_v0" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->v0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_s0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_s0" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((PiecewiseTimeDependentHestonModel const *)arg1)->s0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_timeGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeGrid *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_timeGrid" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (TimeGrid *) &((PiecewiseTimeDependentHestonModel const *)arg1)->timeGrid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_dividendYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_dividendYield" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((PiecewiseTimeDependentHestonModel const *)arg1)->dividendYield();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseTimeDependentHestonModel_riskFreeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseTimeDependentHestonModel_riskFreeRate" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((PiecewiseTimeDependentHestonModel const *)arg1)->riskFreeRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseTimeDependentHestonModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseTimeDependentHestonModel *arg1 = (PiecewiseTimeDependentHestonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempshared1 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseTimeDependentHestonModel" "', argument " "1"" of type '" "PiecewiseTimeDependentHestonModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = const_cast< PiecewiseTimeDependentHestonModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseTimeDependentHestonModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseTimeDependentHestonModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AnalyticHestonEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticHestonEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  AnalyticHestonEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  AnalyticHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticHestonEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticHestonEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  AnalyticHestonEngine::Integration *arg3 = 0 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  AnalyticHestonEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticHestonEngine" "', argument " "2"" of type '" "AnalyticHestonEngine::ComplexLogFormula""'");
  } 
  arg2 = static_cast< AnalyticHestonEngine::ComplexLogFormula >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_AnalyticHestonEngine__Integration,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnalyticHestonEngine" "', argument " "3"" of type '" "AnalyticHestonEngine::Integration const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHestonEngine" "', argument " "3"" of type '" "AnalyticHestonEngine::Integration const &""'"); 
  }
  arg3 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AnalyticHestonEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(AnalyticHestonEngine::Integration const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  AnalyticHestonEngine::ComplexLogFormula arg2 ;
  AnalyticHestonEngine::Integration *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  AnalyticHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticHestonEngine" "', argument " "2"" of type '" "AnalyticHestonEngine::ComplexLogFormula""'");
  } 
  arg2 = static_cast< AnalyticHestonEngine::ComplexLogFormula >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_AnalyticHestonEngine__Integration,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnalyticHestonEngine" "', argument " "3"" of type '" "AnalyticHestonEngine::Integration const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHestonEngine" "', argument " "3"" of type '" "AnalyticHestonEngine::Integration const &""'"); 
  }
  arg3 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp3);
  {
    try {
      result = (AnalyticHestonEngine *)new AnalyticHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(AnalyticHestonEngine::Integration const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticHestonEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticHestonEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnalyticHestonEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_AnalyticHestonEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AnalyticHestonEngine__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_AnalyticHestonEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticHestonEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::AnalyticHestonEngine(ext::shared_ptr< HestonModel > const &,Size)\n"
    "    AnalyticHestonEngine::AnalyticHestonEngine(ext::shared_ptr< HestonModel > const &)\n"
    "    AnalyticHestonEngine::AnalyticHestonEngine(ext::shared_ptr< HestonModel > const &,Real,Size)\n"
    "    AnalyticHestonEngine::AnalyticHestonEngine(ext::shared_ptr< HestonModel > const &,AnalyticHestonEngine::ComplexLogFormula,AnalyticHestonEngine::Integration const &,Real)\n"
    "    AnalyticHestonEngine::AnalyticHestonEngine(ext::shared_ptr< HestonModel > const &,AnalyticHestonEngine::ComplexLogFormula,AnalyticHestonEngine::Integration const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine const > tempshared1 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_numberOfEvaluations" "', argument " "1"" of type '" "AnalyticHestonEngine const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((AnalyticHestonEngine const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_chF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  std::complex< Real > *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine const > tempshared1 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  std::complex< Real > temp2 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::complex< Real > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_chF", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_chF" "', argument " "1"" of type '" "AnalyticHestonEngine const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_chF" "', argument " "2"" of type '" "std::complex< Real >""'");
  } 
  temp2 = static_cast< std::complex< Real > >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnalyticHestonEngine_chF" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((AnalyticHestonEngine const *)arg1)->chF((std::complex< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_lnChF(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  std::complex< Real > *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine const > tempshared1 ;
  ext::shared_ptr< AnalyticHestonEngine const > *smartarg1 = 0 ;
  std::complex< Real > temp2 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::complex< Real > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_lnChF", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_lnChF" "', argument " "1"" of type '" "AnalyticHestonEngine const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_lnChF" "', argument " "2"" of type '" "std::complex< Real >""'");
  } 
  temp2 = static_cast< std::complex< Real > >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnalyticHestonEngine_lnChF" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((AnalyticHestonEngine const *)arg1)->lnChF((std::complex< Real > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine *arg1 = (AnalyticHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine > tempshared1 ;
  ext::shared_ptr< AnalyticHestonEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticHestonEngine" "', argument " "1"" of type '" "AnalyticHestonEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLaguerre__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussLaguerre" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLaguerre(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLaguerre__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLaguerre();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLaguerre(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussLaguerre", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_gaussLaguerre__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_gaussLaguerre__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_gaussLaguerre'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::gaussLaguerre(Size)\n"
    "    AnalyticHestonEngine::Integration::gaussLaguerre()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLegendre__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussLegendre" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLegendre(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLegendre__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLegendre();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLegendre(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussLegendre", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_gaussLegendre__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_gaussLegendre__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_gaussLegendre'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::gaussLegendre(Size)\n"
    "    AnalyticHestonEngine::Integration::gaussLegendre()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussChebyshev__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussChebyshev" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussChebyshev(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussChebyshev__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussChebyshev();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussChebyshev(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussChebyshev", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_gaussChebyshev__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_gaussChebyshev__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_gaussChebyshev'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::gaussChebyshev(Size)\n"
    "    AnalyticHestonEngine::Integration::gaussChebyshev()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussChebyshev2nd" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussChebyshev2nd(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussChebyshev2nd();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussChebyshev2nd", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_gaussChebyshev2nd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::gaussChebyshev2nd(Size)\n"
    "    AnalyticHestonEngine::Integration::gaussChebyshev2nd()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  bool arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLobatto(arg1,arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLobatto(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_gaussLobatto" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussLobatto(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussLobatto(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussLobatto", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_AnalyticHestonEngine_Integration_gaussLobatto__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_gaussLobatto'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::gaussLobatto(Real,Real,Size,bool)\n"
    "    AnalyticHestonEngine::Integration::gaussLobatto(Real,Real,Size)\n"
    "    AnalyticHestonEngine::Integration::gaussLobatto(Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussKronrod" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_gaussKronrod" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussKronrod(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_gaussKronrod" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::gaussKronrod(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_gaussKronrod(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_gaussKronrod", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnalyticHestonEngine_Integration_gaussKronrod__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_gaussKronrod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::gaussKronrod(Real,Size)\n"
    "    AnalyticHestonEngine::Integration::gaussKronrod(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_simpson__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_simpson" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_simpson" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = AnalyticHestonEngine::Integration::simpson(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_simpson__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_simpson" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::simpson(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_simpson(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_simpson", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_simpson__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnalyticHestonEngine_Integration_simpson__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_simpson'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::simpson(Real,Size)\n"
    "    AnalyticHestonEngine::Integration::simpson(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_trapezoid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_trapezoid" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_trapezoid" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = AnalyticHestonEngine::Integration::trapezoid(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_trapezoid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_trapezoid" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::trapezoid(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_trapezoid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_trapezoid", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_trapezoid__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnalyticHestonEngine_Integration_trapezoid__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_trapezoid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::trapezoid(Real,Size)\n"
    "    AnalyticHestonEngine::Integration::trapezoid(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_discreteSimpson__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_discreteSimpson" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::discreteSimpson(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_discreteSimpson__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::discreteSimpson();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_discreteSimpson(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_discreteSimpson", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_discreteSimpson__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_discreteSimpson__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_discreteSimpson'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::discreteSimpson(Size)\n"
    "    AnalyticHestonEngine::Integration::discreteSimpson()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_discreteTrapezoid__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_discreteTrapezoid" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::discreteTrapezoid(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_discreteTrapezoid__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::discreteTrapezoid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_discreteTrapezoid(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_discreteTrapezoid", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_discreteTrapezoid__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_discreteTrapezoid__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_discreteTrapezoid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::discreteTrapezoid(Size)\n"
    "    AnalyticHestonEngine::Integration::discreteTrapezoid()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_expSinh__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_expSinh" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = AnalyticHestonEngine::Integration::expSinh(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_expSinh__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< AnalyticHestonEngine::Integration > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = AnalyticHestonEngine::Integration::expSinh();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new AnalyticHestonEngine::Integration(result)), SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_expSinh(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_expSinh", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_AnalyticHestonEngine_Integration_expSinh__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_AnalyticHestonEngine_Integration_expSinh__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnalyticHestonEngine_Integration_expSinh'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonEngine::Integration::expSinh(Real)\n"
    "    AnalyticHestonEngine::Integration::expSinh()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)AnalyticHestonEngine::Integration::andersenPiterbargIntegrationLimit(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__Integration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_Integration_numberOfEvaluations" "', argument " "1"" of type '" "AnalyticHestonEngine::Integration const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp1);
  {
    try {
      result = ((AnalyticHestonEngine::Integration const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_Integration_isAdaptiveIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__Integration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_Integration_isAdaptiveIntegration" "', argument " "1"" of type '" "AnalyticHestonEngine::Integration const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp1);
  {
    try {
      result = (bool)((AnalyticHestonEngine::Integration const *)arg1)->isAdaptiveIntegration();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHestonEngine_Integration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::Integration *arg1 = (AnalyticHestonEngine::Integration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticHestonEngine_Integration" "', argument " "1"" of type '" "AnalyticHestonEngine::Integration *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::Integration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticHestonEngine_Integration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AnalyticHestonEngine_OptimalAlpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Time arg1 ;
  ext::shared_ptr< AnalyticHestonEngine > *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< AnalyticHestonEngine > tempshared2 ;
  PyObject *swig_obj[2] ;
  AnalyticHestonEngine::OptimalAlpha *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AnalyticHestonEngine_OptimalAlpha", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AnalyticHestonEngine_OptimalAlpha" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticHestonEngine_OptimalAlpha" "', argument " "2"" of type '" "ext::shared_ptr< AnalyticHestonEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< AnalyticHestonEngine > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< AnalyticHestonEngine > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< AnalyticHestonEngine > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (AnalyticHestonEngine::OptimalAlpha *)new_AnalyticHestonEngine_OptimalAlpha(arg1,(ext::shared_ptr< AnalyticHestonEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha___call__" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::pair< Real,Real > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = ((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaGreaterZero(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::pair< Real,Real > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = ((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaSmallerMinusOne(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< double,double > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_numberOfEvaluations" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  {
    try {
      result = ((AnalyticHestonEngine::OptimalAlpha const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha_M", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_M" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha_M" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->M(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_k(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  Integer arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha_k", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_k" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha_k" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnalyticHestonEngine_OptimalAlpha_k" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->k(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_alphaMin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha_alphaMin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaMin" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaMin" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaMin(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AnalyticHestonEngine_OptimalAlpha_alphaMax(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AnalyticHestonEngine_OptimalAlpha_alphaMax", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaMax" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha const *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnalyticHestonEngine_OptimalAlpha_alphaMax" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((AnalyticHestonEngine::OptimalAlpha const *)arg1)->alphaMax(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHestonEngine_OptimalAlpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonEngine::OptimalAlpha *arg1 = (AnalyticHestonEngine::OptimalAlpha *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticHestonEngine_OptimalAlpha" "', argument " "1"" of type '" "AnalyticHestonEngine::OptimalAlpha *""'"); 
  }
  arg1 = reinterpret_cast< AnalyticHestonEngine::OptimalAlpha * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticHestonEngine_OptimalAlpha_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AnalyticHestonEngine__OptimalAlpha, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticHestonEngine_OptimalAlpha_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_COSHestonEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  COSHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_COSHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_COSHestonEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_COSHestonEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (COSHestonEngine *)new COSHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  COSHestonEngine > *smartresult = result ? new ext::shared_ptr<  COSHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_COSHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_COSHestonEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  COSHestonEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_COSHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_COSHestonEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (COSHestonEngine *)new COSHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  COSHestonEngine > *smartresult = result ? new ext::shared_ptr<  COSHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_COSHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_COSHestonEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  COSHestonEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_COSHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (COSHestonEngine *)new COSHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  COSHestonEngine > *smartresult = result ? new ext::shared_ptr<  COSHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_COSHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_COSHestonEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_COSHestonEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_COSHestonEngine__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_COSHestonEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_COSHestonEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_COSHestonEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    COSHestonEngine::COSHestonEngine(ext::shared_ptr< HestonModel > const &,Real,Size)\n"
    "    COSHestonEngine::COSHestonEngine(ext::shared_ptr< HestonModel > const &,Real)\n"
    "    COSHestonEngine::COSHestonEngine(ext::shared_ptr< HestonModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_COSHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COSHestonEngine *arg1 = (COSHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< COSHestonEngine > tempshared1 ;
  ext::shared_ptr< COSHestonEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_COSHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_COSHestonEngine" "', argument " "1"" of type '" "COSHestonEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  COSHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  COSHestonEngine > * >(argp1);
      arg1 = const_cast< COSHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  COSHestonEngine > * >(argp1);
      arg1 = const_cast< COSHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *COSHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_COSHestonEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *COSHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExponentialFittingHestonEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ExponentialFittingHestonEngine::ControlVariate arg2 ;
  doubleOrNull arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "2"" of type '" "ExponentialFittingHestonEngine::ControlVariate""'");
  } 
  arg2 = static_cast< ExponentialFittingHestonEngine::ControlVariate >(val2);
  {
    if (swig_obj[2] == Py_None)
    arg3 = Null<double>();
    else if (PyFloat_Check(swig_obj[2]))
    arg3 = PyFloat_AsDouble(swig_obj[2]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialFittingHestonEngine > *smartresult = result ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialFittingHestonEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ExponentialFittingHestonEngine::ControlVariate arg2 ;
  doubleOrNull arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "2"" of type '" "ExponentialFittingHestonEngine::ControlVariate""'");
  } 
  arg2 = static_cast< ExponentialFittingHestonEngine::ControlVariate >(val2);
  {
    if (swig_obj[2] == Py_None)
    arg3 = Null<double>();
    else if (PyFloat_Check(swig_obj[2]))
    arg3 = PyFloat_AsDouble(swig_obj[2]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialFittingHestonEngine > *smartresult = result ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialFittingHestonEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ExponentialFittingHestonEngine::ControlVariate arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "2"" of type '" "ExponentialFittingHestonEngine::ControlVariate""'");
  } 
  arg2 = static_cast< ExponentialFittingHestonEngine::ControlVariate >(val2);
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialFittingHestonEngine > *smartresult = result ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialFittingHestonEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  ExponentialFittingHestonEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialFittingHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (ExponentialFittingHestonEngine *)new ExponentialFittingHestonEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialFittingHestonEngine > *smartresult = result ? new ext::shared_ptr<  ExponentialFittingHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialFittingHestonEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExponentialFittingHestonEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExponentialFittingHestonEngine__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExponentialFittingHestonEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = (argv[2] == Py_None || PyFloat_Check(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_ExponentialFittingHestonEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = (argv[2] == Py_None || PyFloat_Check(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ExponentialFittingHestonEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExponentialFittingHestonEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExponentialFittingHestonEngine::ExponentialFittingHestonEngine(ext::shared_ptr< HestonModel > const &,ExponentialFittingHestonEngine::ControlVariate,doubleOrNull,Real)\n"
    "    ExponentialFittingHestonEngine::ExponentialFittingHestonEngine(ext::shared_ptr< HestonModel > const &,ExponentialFittingHestonEngine::ControlVariate,doubleOrNull)\n"
    "    ExponentialFittingHestonEngine::ExponentialFittingHestonEngine(ext::shared_ptr< HestonModel > const &,ExponentialFittingHestonEngine::ControlVariate)\n"
    "    ExponentialFittingHestonEngine::ExponentialFittingHestonEngine(ext::shared_ptr< HestonModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExponentialFittingHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExponentialFittingHestonEngine *arg1 = (ExponentialFittingHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExponentialFittingHestonEngine > tempshared1 ;
  ext::shared_ptr< ExponentialFittingHestonEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExponentialFittingHestonEngine" "', argument " "1"" of type '" "ExponentialFittingHestonEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExponentialFittingHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExponentialFittingHestonEngine > * >(argp1);
      arg1 = const_cast< ExponentialFittingHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExponentialFittingHestonEngine > * >(argp1);
      arg1 = const_cast< ExponentialFittingHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExponentialFittingHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExponentialFittingHestonEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExponentialFittingHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticPTDHestonEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPTDHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticPTDHestonEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPTDHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticPTDHestonEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempshared1 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPTDHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticPTDHestonEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  AnalyticPTDHestonEngine::ComplexLogFormula arg2 ;
  AnalyticPTDHestonEngine::Integration *arg3 = 0 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "2"" of type '" "AnalyticPTDHestonEngine::ComplexLogFormula""'");
  } 
  arg2 = static_cast< AnalyticPTDHestonEngine::ComplexLogFormula >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_AnalyticHestonEngine__Integration,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "3"" of type '" "AnalyticPTDHestonEngine::Integration const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticPTDHestonEngine" "', argument " "3"" of type '" "AnalyticPTDHestonEngine::Integration const &""'"); 
  }
  arg3 = reinterpret_cast< AnalyticPTDHestonEngine::Integration * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1,arg2,(AnalyticPTDHestonEngine::Integration const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPTDHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticPTDHestonEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > *arg1 = 0 ;
  AnalyticPTDHestonEngine::ComplexLogFormula arg2 ;
  AnalyticPTDHestonEngine::Integration *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseTimeDependentHestonModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  AnalyticPTDHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PiecewiseTimeDependentHestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "2"" of type '" "AnalyticPTDHestonEngine::ComplexLogFormula""'");
  } 
  arg2 = static_cast< AnalyticPTDHestonEngine::ComplexLogFormula >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_AnalyticHestonEngine__Integration,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnalyticPTDHestonEngine" "', argument " "3"" of type '" "AnalyticPTDHestonEngine::Integration const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticPTDHestonEngine" "', argument " "3"" of type '" "AnalyticPTDHestonEngine::Integration const &""'"); 
  }
  arg3 = reinterpret_cast< AnalyticPTDHestonEngine::Integration * >(argp3);
  {
    try {
      result = (AnalyticPTDHestonEngine *)new AnalyticPTDHestonEngine((ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)*arg1,arg2,(AnalyticPTDHestonEngine::Integration const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPTDHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPTDHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticPTDHestonEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticPTDHestonEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticPTDHestonEngine__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnalyticPTDHestonEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_AnalyticPTDHestonEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AnalyticPTDHestonEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_AnalyticHestonEngine__Integration, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_AnalyticPTDHestonEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticPTDHestonEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticPTDHestonEngine::AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &,Real,Size)\n"
    "    AnalyticPTDHestonEngine::AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &,Size)\n"
    "    AnalyticPTDHestonEngine::AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &)\n"
    "    AnalyticPTDHestonEngine::AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &,AnalyticPTDHestonEngine::ComplexLogFormula,AnalyticPTDHestonEngine::Integration const &,Real)\n"
    "    AnalyticPTDHestonEngine::AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const &,AnalyticPTDHestonEngine::ComplexLogFormula,AnalyticPTDHestonEngine::Integration const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticPTDHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticPTDHestonEngine *arg1 = (AnalyticPTDHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticPTDHestonEngine > tempshared1 ;
  ext::shared_ptr< AnalyticPTDHestonEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticPTDHestonEngine" "', argument " "1"" of type '" "AnalyticPTDHestonEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticPTDHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticPTDHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticPTDHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticPTDHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticPTDHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticPTDHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticPTDHestonEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticPTDHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BatesModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  BatesModel *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BatesModel" "', argument " "1"" of type '" "ext::shared_ptr< BatesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (BatesModel *)new BatesModel((ext::shared_ptr< BatesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BatesModel > *smartresult = result ? new ext::shared_ptr<  BatesModel >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BatesModel_nu(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BatesModel *arg1 = (BatesModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel const > tempshared1 ;
  ext::shared_ptr< BatesModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BatesModel_nu" "', argument " "1"" of type '" "BatesModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BatesModel const *)arg1)->nu();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BatesModel_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BatesModel *arg1 = (BatesModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel const > tempshared1 ;
  ext::shared_ptr< BatesModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BatesModel_delta" "', argument " "1"" of type '" "BatesModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BatesModel const *)arg1)->delta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BatesModel_lambda_parameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BatesModel *arg1 = (BatesModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel const > tempshared1 ;
  ext::shared_ptr< BatesModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BatesModel_lambda_parameter" "', argument " "1"" of type '" "BatesModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BatesModel const *)arg1)->lambda();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BatesModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BatesModel *arg1 = (BatesModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  ext::shared_ptr< BatesModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BatesModel" "', argument " "1"" of type '" "BatesModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BatesModel > * >(argp1);
      arg1 = const_cast< BatesModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BatesModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BatesModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BatesEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BatesEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BatesEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BatesEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BatesEngine *)new BatesEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BatesEngine > *smartresult = result ? new ext::shared_ptr<  BatesEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BatesEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BatesEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  BatesEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BatesEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (BatesEngine *)new BatesEngine((ext::shared_ptr< BatesModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BatesEngine > *smartresult = result ? new ext::shared_ptr<  BatesEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BatesEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BatesEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BatesEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BatesEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BatesEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BatesEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BatesEngine *)new BatesEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BatesEngine > *smartresult = result ? new ext::shared_ptr<  BatesEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BatesEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BatesEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BatesEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BatesEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BatesEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BatesEngine__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BatesEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BatesEngine::BatesEngine(ext::shared_ptr< BatesModel > const &,Size)\n"
    "    BatesEngine::BatesEngine(ext::shared_ptr< BatesModel > const &)\n"
    "    BatesEngine::BatesEngine(ext::shared_ptr< BatesModel > const &,Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BatesEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BatesEngine *arg1 = (BatesEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesEngine > tempshared1 ;
  ext::shared_ptr< BatesEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BatesEngine" "', argument " "1"" of type '" "BatesEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BatesEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BatesEngine > * >(argp1);
      arg1 = const_cast< BatesEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BatesEngine > * >(argp1);
      arg1 = const_cast< BatesEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BatesEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BatesEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BatesEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IntegralEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  IntegralEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntegralEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (IntegralEngine *)new IntegralEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IntegralEngine > *smartresult = result ? new ext::shared_ptr<  IntegralEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IntegralEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntegralEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntegralEngine *arg1 = (IntegralEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IntegralEngine > tempshared1 ;
  ext::shared_ptr< IntegralEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IntegralEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntegralEngine" "', argument " "1"" of type '" "IntegralEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IntegralEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IntegralEngine > * >(argp1);
      arg1 = const_cast< IntegralEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IntegralEngine > * >(argp1);
      arg1 = const_cast< IntegralEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntegralEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IntegralEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntegralEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialCRRVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< CoxRossRubinstein > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialCRRVanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialCRRVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialCRRVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< CoxRossRubinstein > *)new BinomialVanillaEngine< CoxRossRubinstein >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialCRRVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< CoxRossRubinstein > *arg1 = (BinomialVanillaEngine< CoxRossRubinstein > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialCRRVanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< CoxRossRubinstein > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< CoxRossRubinstein > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<CoxRossRubinstein> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< CoxRossRubinstein > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialCRRVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialCRRVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJRVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< JarrowRudd > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialJRVanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJRVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJRVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< JarrowRudd > *)new BinomialVanillaEngine< JarrowRudd >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJRVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< JarrowRudd > *arg1 = (BinomialVanillaEngine< JarrowRudd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJRVanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< JarrowRudd > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< JarrowRudd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<JarrowRudd> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< JarrowRudd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJRVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJRVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialEQPVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialEQPVanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialEQPVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialEQPVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< AdditiveEQPBinomialTree > *)new BinomialVanillaEngine< AdditiveEQPBinomialTree >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialEQPVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< AdditiveEQPBinomialTree > *arg1 = (BinomialVanillaEngine< AdditiveEQPBinomialTree > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialEQPVanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< AdditiveEQPBinomialTree > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< AdditiveEQPBinomialTree > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<AdditiveEQPBinomialTree> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< AdditiveEQPBinomialTree > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialEQPVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialEQPVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< Trigeorgis > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialTrigeorgisVanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTrigeorgisVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTrigeorgisVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< Trigeorgis > *)new BinomialVanillaEngine< Trigeorgis >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTrigeorgisVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< Trigeorgis > *arg1 = (BinomialVanillaEngine< Trigeorgis > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTrigeorgisVanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< Trigeorgis > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< Trigeorgis > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Trigeorgis> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< Trigeorgis > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTrigeorgisVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTrigeorgisVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTianVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< Tian > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialTianVanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTianVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTianVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< Tian > *)new BinomialVanillaEngine< Tian >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<Tian> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<Tian> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTianVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< Tian > *arg1 = (BinomialVanillaEngine< Tian > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< Tian > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< Tian > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTianVanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< Tian > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Tian> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Tian> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< Tian > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Tian> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< Tian > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTianVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTianVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialLRVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< LeisenReimer > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialLRVanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialLRVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialLRVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< LeisenReimer > *)new BinomialVanillaEngine< LeisenReimer >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialLRVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< LeisenReimer > *arg1 = (BinomialVanillaEngine< LeisenReimer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialLRVanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< LeisenReimer > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< LeisenReimer > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<LeisenReimer> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< LeisenReimer > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialLRVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialLRVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJ4VanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialVanillaEngine< Joshi4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialJ4VanillaEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJ4VanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJ4VanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialVanillaEngine< Joshi4 > *)new BinomialVanillaEngine< Joshi4 >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialVanillaEngine<Joshi4> > *smartresult = result ? new ext::shared_ptr<  BinomialVanillaEngine<Joshi4> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJ4VanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialVanillaEngine< Joshi4 > *arg1 = (BinomialVanillaEngine< Joshi4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > tempshared1 ;
  ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJ4VanillaEngine" "', argument " "1"" of type '" "BinomialVanillaEngine< Joshi4 > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Joshi4> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Joshi4> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< Joshi4 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialVanillaEngine<Joshi4> > * >(argp1);
      arg1 = const_cast< BinomialVanillaEngine< Joshi4 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJ4VanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJ4VanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LsmBasisSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LsmBasisSystem *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LsmBasisSystem", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (LsmBasisSystem *)new LsmBasisSystem();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LsmBasisSystem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LsmBasisSystem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LsmBasisSystem *arg1 = (LsmBasisSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LsmBasisSystem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LsmBasisSystem" "', argument " "1"" of type '" "LsmBasisSystem *""'"); 
  }
  arg1 = reinterpret_cast< LsmBasisSystem * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LsmBasisSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LsmBasisSystem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LsmBasisSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPREuropeanEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPREuropeanEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPREuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPREuropeanEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPREuropeanEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPREuropeanEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCEuropeanEngine< PseudoRandom > *)new_MCEuropeanEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPREuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanEngine< PseudoRandom > *arg1 = (MCEuropeanEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPREuropeanEngine" "', argument " "1"" of type '" "MCEuropeanEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPREuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPREuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDEuropeanEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDEuropeanEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDEuropeanEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDEuropeanEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDEuropeanEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCEuropeanEngine< LowDiscrepancy > *)new_MCEuropeanEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanEngine< LowDiscrepancy > *arg1 = (MCEuropeanEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDEuropeanEngine" "', argument " "1"" of type '" "MCEuropeanEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRAmericanEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  intOrNull arg10 = (intOrNull) 2 ;
  LsmBasisSystem::PolynomialType arg11 = (LsmBasisSystem::PolynomialType) LsmBasisSystem::Monomial ;
  int arg12 = (int) 2048 ;
  ext::optional< bool > arg13 = (ext::optional< bool >) ext::nullopt ;
  BigNatural arg14 = (BigNatural) Null< Size >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  unsigned long val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"controlVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"polynomOrder",  (char *)"polynomType",  (char *)"nCalibrationSamples",  (char *)"antitheticVariateCalibration",  (char *)"seedCalibration",  NULL 
  };
  MCAmericanEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOOOOOO:new_MCPRAmericanEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRAmericanEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPRAmericanEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRAmericanEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  if (obj9) {
    {
      if (obj9 == Py_None)
      arg10 = Null<int>();
      else if (PyInt_Check(obj9))
      arg10 = int(PyInt_AsLong(obj9));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_int(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_MCPRAmericanEngine" "', argument " "11"" of type '" "LsmBasisSystem::PolynomialType""'");
    } 
    arg11 = static_cast< LsmBasisSystem::PolynomialType >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_MCPRAmericanEngine" "', argument " "12"" of type '" "int""'");
    } 
    arg12 = static_cast< int >(val12);
  }
  if (obj12) {
    if(obj12 == Py_None)
    arg13 = ext::nullopt;
    else if (obj12 == Py_True)
    arg13 = true;
    else
    arg13 = false;
    
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_unsigned_SS_long(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_MCPRAmericanEngine" "', argument " "14"" of type '" "BigNatural""'");
    } 
    arg14 = static_cast< BigNatural >(val14);
  }
  {
    try {
      result = (MCAmericanEngine< PseudoRandom > *)new_MCAmericanEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(arg10),arg11,arg12,SWIG_STD_MOVE(arg13),arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCAmericanEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCAmericanEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRAmericanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCAmericanEngine< PseudoRandom > *arg1 = (MCAmericanEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCAmericanEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCAmericanEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRAmericanEngine" "', argument " "1"" of type '" "MCAmericanEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCAmericanEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCAmericanEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCAmericanEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCAmericanEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCAmericanEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRAmericanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRAmericanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDAmericanEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  intOrNull arg10 = (intOrNull) 2 ;
  LsmBasisSystem::PolynomialType arg11 = (LsmBasisSystem::PolynomialType) LsmBasisSystem::Monomial ;
  int arg12 = (int) 2048 ;
  ext::optional< bool > arg13 = (ext::optional< bool >) ext::nullopt ;
  BigNatural arg14 = (BigNatural) Null< Size >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long val9 ;
  int ecode9 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  unsigned long val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"controlVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"polynomOrder",  (char *)"polynomType",  (char *)"nCalibrationSamples",  (char *)"antitheticVariateCalibration",  (char *)"seedCalibration",  NULL 
  };
  MCAmericanEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOOOOOO:new_MCLDAmericanEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDAmericanEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDAmericanEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDAmericanEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  if (obj9) {
    {
      if (obj9 == Py_None)
      arg10 = Null<int>();
      else if (PyInt_Check(obj9))
      arg10 = int(PyInt_AsLong(obj9));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_int(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_MCLDAmericanEngine" "', argument " "11"" of type '" "LsmBasisSystem::PolynomialType""'");
    } 
    arg11 = static_cast< LsmBasisSystem::PolynomialType >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_MCLDAmericanEngine" "', argument " "12"" of type '" "int""'");
    } 
    arg12 = static_cast< int >(val12);
  }
  if (obj12) {
    if(obj12 == Py_None)
    arg13 = ext::nullopt;
    else if (obj12 == Py_True)
    arg13 = true;
    else
    arg13 = false;
    
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_unsigned_SS_long(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_MCLDAmericanEngine" "', argument " "14"" of type '" "BigNatural""'");
    } 
    arg14 = static_cast< BigNatural >(val14);
  }
  {
    try {
      result = (MCAmericanEngine< LowDiscrepancy > *)new_MCAmericanEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(arg10),arg11,arg12,SWIG_STD_MOVE(arg13),arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDAmericanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCAmericanEngine< LowDiscrepancy > *arg1 = (MCAmericanEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDAmericanEngine" "', argument " "1"" of type '" "MCAmericanEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCAmericanEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCAmericanEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCAmericanEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDAmericanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDAmericanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPREuropeanHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCPREuropeanHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPREuropeanHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPREuropeanHestonEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCPREuropeanHestonEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  {
    try {
      result = (MCEuropeanHestonEngine< PseudoRandom > *)new_MCEuropeanHestonEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPREuropeanHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanHestonEngine< PseudoRandom > *arg1 = (MCEuropeanHestonEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPREuropeanHestonEngine" "', argument " "1"" of type '" "MCEuropeanHestonEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanHestonEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanHestonEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPREuropeanHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPREuropeanHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDEuropeanHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCLDEuropeanHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDEuropeanHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDEuropeanHestonEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCLDEuropeanHestonEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  {
    try {
      result = (MCEuropeanHestonEngine< LowDiscrepancy > *)new_MCEuropeanHestonEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDEuropeanHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanHestonEngine< LowDiscrepancy > *arg1 = (MCEuropeanHestonEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDEuropeanHestonEngine" "', argument " "1"" of type '" "MCEuropeanHestonEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanHestonEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanHestonEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDEuropeanHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDEuropeanHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRDigitalEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDigitalEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPRDigitalEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRDigitalEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRDigitalEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPRDigitalEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRDigitalEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCDigitalEngine< PseudoRandom > *)new_MCDigitalEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDigitalEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCDigitalEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRDigitalEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDigitalEngine< PseudoRandom > *arg1 = (MCDigitalEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDigitalEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCDigitalEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRDigitalEngine" "', argument " "1"" of type '" "MCDigitalEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDigitalEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDigitalEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDigitalEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDigitalEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDigitalEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRDigitalEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRDigitalEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDDigitalEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDigitalEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDDigitalEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDDigitalEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDDigitalEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDDigitalEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDDigitalEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCDigitalEngine< LowDiscrepancy > *)new_MCDigitalEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDDigitalEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDigitalEngine< LowDiscrepancy > *arg1 = (MCDigitalEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDigitalEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCDigitalEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDDigitalEngine" "', argument " "1"" of type '" "MCDigitalEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDigitalEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDigitalEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDigitalEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDDigitalEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDigitalEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDDigitalEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BaroneAdesiWhaleyApproximationEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  BaroneAdesiWhaleyApproximationEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BaroneAdesiWhaleyApproximationEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (BaroneAdesiWhaleyApproximationEngine *)new BaroneAdesiWhaleyApproximationEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine > *smartresult = result ? new ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BaroneAdesiWhaleyApproximationEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BaroneAdesiWhaleyApproximationEngine *arg1 = (BaroneAdesiWhaleyApproximationEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > tempshared1 ;
  ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BaroneAdesiWhaleyApproximationEngine" "', argument " "1"" of type '" "BaroneAdesiWhaleyApproximationEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine > * >(argp1);
      arg1 = const_cast< BaroneAdesiWhaleyApproximationEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BaroneAdesiWhaleyApproximationEngine > * >(argp1);
      arg1 = const_cast< BaroneAdesiWhaleyApproximationEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BaroneAdesiWhaleyApproximationEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BaroneAdesiWhaleyApproximationEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BjerksundStenslandApproximationEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  BjerksundStenslandApproximationEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BjerksundStenslandApproximationEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (BjerksundStenslandApproximationEngine *)new BjerksundStenslandApproximationEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BjerksundStenslandApproximationEngine > *smartresult = result ? new ext::shared_ptr<  BjerksundStenslandApproximationEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BjerksundStenslandApproximationEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BjerksundStenslandApproximationEngine *arg1 = (BjerksundStenslandApproximationEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BjerksundStenslandApproximationEngine > tempshared1 ;
  ext::shared_ptr< BjerksundStenslandApproximationEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BjerksundStenslandApproximationEngine" "', argument " "1"" of type '" "BjerksundStenslandApproximationEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BjerksundStenslandApproximationEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BjerksundStenslandApproximationEngine > * >(argp1);
      arg1 = const_cast< BjerksundStenslandApproximationEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BjerksundStenslandApproximationEngine > * >(argp1);
      arg1 = const_cast< BjerksundStenslandApproximationEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BjerksundStenslandApproximationEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BjerksundStenslandApproximationEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_JuQuadraticApproximationEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  JuQuadraticApproximationEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JuQuadraticApproximationEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (JuQuadraticApproximationEngine *)new JuQuadraticApproximationEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JuQuadraticApproximationEngine > *smartresult = result ? new ext::shared_ptr<  JuQuadraticApproximationEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JuQuadraticApproximationEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JuQuadraticApproximationEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  JuQuadraticApproximationEngine *arg1 = (JuQuadraticApproximationEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< JuQuadraticApproximationEngine > tempshared1 ;
  ext::shared_ptr< JuQuadraticApproximationEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_JuQuadraticApproximationEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JuQuadraticApproximationEngine" "', argument " "1"" of type '" "JuQuadraticApproximationEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  JuQuadraticApproximationEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  JuQuadraticApproximationEngine > * >(argp1);
      arg1 = const_cast< JuQuadraticApproximationEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  JuQuadraticApproximationEngine > * >(argp1);
      arg1 = const_cast< JuQuadraticApproximationEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JuQuadraticApproximationEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_JuQuadraticApproximationEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *JuQuadraticApproximationEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDigitalAmericanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticDigitalAmericanEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDigitalAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDigitalAmericanEngine *)new AnalyticDigitalAmericanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDigitalAmericanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDigitalAmericanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDigitalAmericanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDigitalAmericanEngine *arg1 = (AnalyticDigitalAmericanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDigitalAmericanEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDigitalAmericanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDigitalAmericanEngine" "', argument " "1"" of type '" "AnalyticDigitalAmericanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDigitalAmericanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDigitalAmericanEngine > * >(argp1);
      arg1 = const_cast< AnalyticDigitalAmericanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDigitalAmericanEngine > * >(argp1);
      arg1 = const_cast< AnalyticDigitalAmericanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDigitalAmericanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDigitalAmericanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDigitalAmericanKOEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticDigitalAmericanKOEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDigitalAmericanKOEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDigitalAmericanKOEngine *)new AnalyticDigitalAmericanKOEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDigitalAmericanKOEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDigitalAmericanKOEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDigitalAmericanKOEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDigitalAmericanKOEngine *arg1 = (AnalyticDigitalAmericanKOEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDigitalAmericanKOEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDigitalAmericanKOEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDigitalAmericanKOEngine" "', argument " "1"" of type '" "AnalyticDigitalAmericanKOEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDigitalAmericanKOEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDigitalAmericanKOEngine > * >(argp1);
      arg1 = const_cast< AnalyticDigitalAmericanKOEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDigitalAmericanKOEngine > * >(argp1);
      arg1 = const_cast< AnalyticDigitalAmericanKOEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDigitalAmericanKOEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDigitalAmericanKOEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DividendVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  PyObject *swig_obj[4] ;
  DividendVanillaOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DividendVanillaOption", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DividendVanillaOption" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DividendVanillaOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DividendVanillaOption" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DividendVanillaOption" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DividendVanillaOption" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DividendVanillaOption" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (DividendVanillaOption *)new DividendVanillaOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DividendVanillaOption > *smartresult = result ? new ext::shared_ptr<  DividendVanillaOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendVanillaOption_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendVanillaOption > tempshared1 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "1"" of type '" "DividendVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendVanillaOption_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendVanillaOption > tempshared1 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "1"" of type '" "DividendVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendVanillaOption_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendVanillaOption > tempshared1 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "1"" of type '" "DividendVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendVanillaOption_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendVanillaOption > tempshared1 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "1"" of type '" "DividendVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendVanillaOption_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendVanillaOption > tempshared1 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "1"" of type '" "DividendVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DividendVanillaOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DividendVanillaOption_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DividendVanillaOption_impliedVolatility", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DividendVanillaOption_impliedVolatility__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DividendVanillaOption_impliedVolatility__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_DividendVanillaOption_impliedVolatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_DividendVanillaOption_impliedVolatility__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_DividendVanillaOption_impliedVolatility__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DividendVanillaOption_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DividendVanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Volatility,Volatility)\n"
    "    DividendVanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Volatility)\n"
    "    DividendVanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size)\n"
    "    DividendVanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real)\n"
    "    DividendVanillaOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DividendVanillaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DividendVanillaOption *arg1 = (DividendVanillaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendVanillaOption > tempshared1 ;
  ext::shared_ptr< DividendVanillaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DividendVanillaOption" "', argument " "1"" of type '" "DividendVanillaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendVanillaOption > * >(argp1);
      arg1 = const_cast< DividendVanillaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DividendVanillaOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DividendVanillaOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DividendVanillaOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDividendEuropeanEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  AnalyticDividendEuropeanEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDividendEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDividendEuropeanEngine *)new AnalyticDividendEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDividendEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDividendEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticDividendEuropeanEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  AnalyticDividendEuropeanEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDividendEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_AnalyticDividendEuropeanEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (AnalyticDividendEuropeanEngine *)new AnalyticDividendEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDividendEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDividendEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticDividendEuropeanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticDividendEuropeanEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticDividendEuropeanEngine__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AnalyticDividendEuropeanEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticDividendEuropeanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticDividendEuropeanEngine::AnalyticDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    AnalyticDividendEuropeanEngine::AnalyticDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDividendEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDividendEuropeanEngine *arg1 = (AnalyticDividendEuropeanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDividendEuropeanEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDividendEuropeanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDividendEuropeanEngine" "', argument " "1"" of type '" "AnalyticDividendEuropeanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDividendEuropeanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDividendEuropeanEngine > * >(argp1);
      arg1 = const_cast< AnalyticDividendEuropeanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDividendEuropeanEngine > * >(argp1);
      arg1 = const_cast< AnalyticDividendEuropeanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDividendEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDividendEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QdPlusAmericanEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 = (Size) 8 ;
  QdPlusAmericanEngine::SolverType arg3 = (QdPlusAmericanEngine::SolverType) QdPlusAmericanEngine::Halley ;
  Real arg4 = (Real) 1e-6 ;
  Size arg5 = (Size) Null< Size >() ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"interpolationPoints",  (char *)"solverType",  (char *)"eps",  (char *)"maxIter",  NULL 
  };
  QdPlusAmericanEngine *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:new_QdPlusAmericanEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QdPlusAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QdPlusAmericanEngine" "', argument " "2"" of type '" "Size""'");
    } 
    arg2 = static_cast< Size >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QdPlusAmericanEngine" "', argument " "3"" of type '" "QdPlusAmericanEngine::SolverType""'");
    } 
    arg3 = static_cast< QdPlusAmericanEngine::SolverType >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_double(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_QdPlusAmericanEngine" "', argument " "4"" of type '" "Real""'");
    } 
    arg4 = static_cast< Real >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_size_t(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_QdPlusAmericanEngine" "', argument " "5"" of type '" "Size""'");
    } 
    arg5 = static_cast< Size >(val5);
  }
  {
    try {
      result = (QdPlusAmericanEngine *)new QdPlusAmericanEngine(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdPlusAmericanEngine > *smartresult = result ? new ext::shared_ptr<  QdPlusAmericanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdPlusAmericanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QdPlusAmericanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QdPlusAmericanEngine *arg1 = (QdPlusAmericanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QdPlusAmericanEngine > tempshared1 ;
  ext::shared_ptr< QdPlusAmericanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QdPlusAmericanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QdPlusAmericanEngine" "', argument " "1"" of type '" "QdPlusAmericanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QdPlusAmericanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QdPlusAmericanEngine > * >(argp1);
      arg1 = const_cast< QdPlusAmericanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QdPlusAmericanEngine > * >(argp1);
      arg1 = const_cast< QdPlusAmericanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QdPlusAmericanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QdPlusAmericanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QdPlusAmericanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_QdFpIterationScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QdFpIterationScheme *arg1 = (QdFpIterationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QdFpIterationScheme > tempshared1 ;
  ext::shared_ptr< QdFpIterationScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QdFpIterationScheme" "', argument " "1"" of type '" "QdFpIterationScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QdFpIterationScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QdFpIterationScheme > * >(argp1);
      arg1 = const_cast< QdFpIterationScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QdFpIterationScheme > * >(argp1);
      arg1 = const_cast< QdFpIterationScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QdFpIterationScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QdFpLegendreScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  QdFpLegendreScheme *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QdFpLegendreScheme", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QdFpLegendreScheme" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QdFpLegendreScheme" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QdFpLegendreScheme" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_QdFpLegendreScheme" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (QdFpLegendreScheme *)new QdFpLegendreScheme(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpLegendreScheme > *smartresult = result ? new ext::shared_ptr<  QdFpLegendreScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QdFpLegendreScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QdFpLegendreScheme *arg1 = (QdFpLegendreScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QdFpLegendreScheme > tempshared1 ;
  ext::shared_ptr< QdFpLegendreScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QdFpLegendreScheme" "', argument " "1"" of type '" "QdFpLegendreScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QdFpLegendreScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QdFpLegendreScheme > * >(argp1);
      arg1 = const_cast< QdFpLegendreScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QdFpLegendreScheme > * >(argp1);
      arg1 = const_cast< QdFpLegendreScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QdFpLegendreScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QdFpLegendreScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QdFpLegendreTanhSinhScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Size arg3 ;
  Real arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  QdFpLegendreTanhSinhScheme *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QdFpLegendreTanhSinhScheme", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QdFpLegendreTanhSinhScheme" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QdFpLegendreTanhSinhScheme" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QdFpLegendreTanhSinhScheme" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_QdFpLegendreTanhSinhScheme" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (QdFpLegendreTanhSinhScheme *)new QdFpLegendreTanhSinhScheme(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpLegendreTanhSinhScheme > *smartresult = result ? new ext::shared_ptr<  QdFpLegendreTanhSinhScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreTanhSinhScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QdFpLegendreTanhSinhScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QdFpLegendreTanhSinhScheme *arg1 = (QdFpLegendreTanhSinhScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QdFpLegendreTanhSinhScheme > tempshared1 ;
  ext::shared_ptr< QdFpLegendreTanhSinhScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreTanhSinhScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QdFpLegendreTanhSinhScheme" "', argument " "1"" of type '" "QdFpLegendreTanhSinhScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QdFpLegendreTanhSinhScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QdFpLegendreTanhSinhScheme > * >(argp1);
      arg1 = const_cast< QdFpLegendreTanhSinhScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QdFpLegendreTanhSinhScheme > * >(argp1);
      arg1 = const_cast< QdFpLegendreTanhSinhScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QdFpLegendreTanhSinhScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QdFpLegendreTanhSinhScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QdFpLegendreTanhSinhScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QdFpTanhSinhIterationScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Real arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  QdFpTanhSinhIterationScheme *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QdFpTanhSinhIterationScheme", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QdFpTanhSinhIterationScheme" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QdFpTanhSinhIterationScheme" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QdFpTanhSinhIterationScheme" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (QdFpTanhSinhIterationScheme *)new QdFpTanhSinhIterationScheme(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpTanhSinhIterationScheme > *smartresult = result ? new ext::shared_ptr<  QdFpTanhSinhIterationScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpTanhSinhIterationScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QdFpTanhSinhIterationScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QdFpTanhSinhIterationScheme *arg1 = (QdFpTanhSinhIterationScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QdFpTanhSinhIterationScheme > tempshared1 ;
  ext::shared_ptr< QdFpTanhSinhIterationScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QdFpTanhSinhIterationScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QdFpTanhSinhIterationScheme" "', argument " "1"" of type '" "QdFpTanhSinhIterationScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QdFpTanhSinhIterationScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QdFpTanhSinhIterationScheme > * >(argp1);
      arg1 = const_cast< QdFpTanhSinhIterationScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QdFpTanhSinhIterationScheme > * >(argp1);
      arg1 = const_cast< QdFpTanhSinhIterationScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QdFpTanhSinhIterationScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QdFpTanhSinhIterationScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QdFpTanhSinhIterationScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QdFpAmericanEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< QdFpIterationScheme > arg2 ;
  QdFpAmericanEngine::FixedPointEquation arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  QdFpAmericanEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QdFpAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QdFpAmericanEngine" "', argument " "2"" of type '" "ext::shared_ptr< QdFpIterationScheme >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< QdFpIterationScheme > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< QdFpIterationScheme > * >(argp2);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QdFpAmericanEngine" "', argument " "3"" of type '" "QdFpAmericanEngine::FixedPointEquation""'");
  } 
  arg3 = static_cast< QdFpAmericanEngine::FixedPointEquation >(val3);
  {
    try {
      result = (QdFpAmericanEngine *)new QdFpAmericanEngine(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpAmericanEngine > *smartresult = result ? new ext::shared_ptr<  QdFpAmericanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpAmericanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QdFpAmericanEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< QdFpIterationScheme > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  QdFpAmericanEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QdFpAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QdFpAmericanEngine" "', argument " "2"" of type '" "ext::shared_ptr< QdFpIterationScheme >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< QdFpIterationScheme > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< QdFpIterationScheme > * >(argp2);
  }
  {
    try {
      result = (QdFpAmericanEngine *)new QdFpAmericanEngine(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpAmericanEngine > *smartresult = result ? new ext::shared_ptr<  QdFpAmericanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpAmericanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QdFpAmericanEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  QdFpAmericanEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QdFpAmericanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    try {
      result = (QdFpAmericanEngine *)new QdFpAmericanEngine(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpAmericanEngine > *smartresult = result ? new ext::shared_ptr<  QdFpAmericanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpAmericanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QdFpAmericanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_QdFpAmericanEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QdFpAmericanEngine__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_QdFpAmericanEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_QdFpAmericanEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QdFpAmericanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    QdFpAmericanEngine::QdFpAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,ext::shared_ptr< QdFpIterationScheme >,QdFpAmericanEngine::FixedPointEquation)\n"
    "    QdFpAmericanEngine::QdFpAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,ext::shared_ptr< QdFpIterationScheme >)\n"
    "    QdFpAmericanEngine::QdFpAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_QdFpAmericanEngine_fastScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< QdFpIterationScheme > result;
  
  if (!SWIG_Python_UnpackTuple(args, "QdFpAmericanEngine_fastScheme", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = QdFpAmericanEngine::fastScheme();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpIterationScheme > *smartresult = result ? new ext::shared_ptr<  QdFpIterationScheme >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QdFpAmericanEngine_accurateScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< QdFpIterationScheme > result;
  
  if (!SWIG_Python_UnpackTuple(args, "QdFpAmericanEngine_accurateScheme", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = QdFpAmericanEngine::accurateScheme();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpIterationScheme > *smartresult = result ? new ext::shared_ptr<  QdFpIterationScheme >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QdFpAmericanEngine_highPrecisionScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< QdFpIterationScheme > result;
  
  if (!SWIG_Python_UnpackTuple(args, "QdFpAmericanEngine_highPrecisionScheme", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = QdFpAmericanEngine::highPrecisionScheme();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QdFpIterationScheme > *smartresult = result ? new ext::shared_ptr<  QdFpIterationScheme >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QdFpIterationScheme_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QdFpAmericanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QdFpAmericanEngine *arg1 = (QdFpAmericanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QdFpAmericanEngine > tempshared1 ;
  ext::shared_ptr< QdFpAmericanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QdFpAmericanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QdFpAmericanEngine" "', argument " "1"" of type '" "QdFpAmericanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QdFpAmericanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QdFpAmericanEngine > * >(argp1);
      arg1 = const_cast< QdFpAmericanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QdFpAmericanEngine > * >(argp1);
      arg1 = const_cast< QdFpAmericanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QdFpAmericanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QdFpAmericanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QdFpAmericanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSchemeDesc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSchemeDesc::FdmSchemeType arg1 ;
  Real arg2 ;
  Real arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  FdmSchemeDesc *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmSchemeDesc", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmSchemeDesc" "', argument " "1"" of type '" "FdmSchemeDesc::FdmSchemeType""'");
  } 
  arg1 = static_cast< FdmSchemeDesc::FdmSchemeType >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmSchemeDesc" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSchemeDesc" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (FdmSchemeDesc *)new FdmSchemeDesc(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FdmSchemeDesc::FdmSchemeType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSchemeDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSchemeDesc_type_get" "', argument " "1"" of type '" "FdmSchemeDesc *""'"); 
  }
  arg1 = reinterpret_cast< FdmSchemeDesc * >(argp1);
  result = (FdmSchemeDesc::FdmSchemeType)(FdmSchemeDesc::FdmSchemeType) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_theta_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSchemeDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSchemeDesc_theta_get" "', argument " "1"" of type '" "FdmSchemeDesc *""'"); 
  }
  arg1 = reinterpret_cast< FdmSchemeDesc * >(argp1);
  result = (Real)(Real) ((arg1)->theta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_mu_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSchemeDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSchemeDesc_mu_get" "', argument " "1"" of type '" "FdmSchemeDesc *""'"); 
  }
  arg1 = reinterpret_cast< FdmSchemeDesc * >(argp1);
  result = (Real)(Real) ((arg1)->mu);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_Douglas(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_Douglas", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::Douglas();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_CrankNicolson(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_CrankNicolson", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::CrankNicolson();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ImplicitEuler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_ImplicitEuler", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::ImplicitEuler();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ExplicitEuler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_ExplicitEuler", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::ExplicitEuler();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_CraigSneyd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_CraigSneyd", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::CraigSneyd();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ModifiedCraigSneyd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_ModifiedCraigSneyd", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::ModifiedCraigSneyd();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_Hundsdorfer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_Hundsdorfer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::Hundsdorfer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_ModifiedHundsdorfer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_ModifiedHundsdorfer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::ModifiedHundsdorfer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FdmSchemeDesc_MethodOfLines" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmSchemeDesc_MethodOfLines" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = FdmSchemeDesc::MethodOfLines(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FdmSchemeDesc_MethodOfLines" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = FdmSchemeDesc::MethodOfLines(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::MethodOfLines();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_MethodOfLines(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_MethodOfLines", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_FdmSchemeDesc_MethodOfLines__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_FdmSchemeDesc_MethodOfLines__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmSchemeDesc_MethodOfLines__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmSchemeDesc_MethodOfLines'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmSchemeDesc::MethodOfLines(Real,Real)\n"
    "    FdmSchemeDesc::MethodOfLines(Real)\n"
    "    FdmSchemeDesc::MethodOfLines()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmSchemeDesc_TrBDF2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< FdmSchemeDesc > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmSchemeDesc_TrBDF2", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = FdmSchemeDesc::TrBDF2();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmSchemeDesc(result)), SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmSchemeDesc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSchemeDesc *arg1 = (FdmSchemeDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSchemeDesc" "', argument " "1"" of type '" "FdmSchemeDesc *""'"); 
  }
  arg1 = reinterpret_cast< FdmSchemeDesc * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSchemeDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FdmSchemeDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSchemeDesc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmQuantoHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YieldTermStructure > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BlackVolTermStructure > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  FdmQuantoHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmQuantoHelper", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmQuantoHelper" "', argument " "1"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmQuantoHelper" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BlackVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmQuantoHelper" "', argument " "3"" of type '" "ext::shared_ptr< BlackVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BlackVolTermStructure > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmQuantoHelper" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmQuantoHelper" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FdmQuantoHelper *)new FdmQuantoHelper((ext::shared_ptr< YieldTermStructure > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< BlackVolTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmQuantoHelper > *smartresult = result ? new ext::shared_ptr<  FdmQuantoHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmQuantoHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmQuantoHelper *arg1 = (FdmQuantoHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared1 ;
  ext::shared_ptr< FdmQuantoHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmQuantoHelper" "', argument " "1"" of type '" "FdmQuantoHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmQuantoHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmQuantoHelper > * >(argp1);
      arg1 = const_cast< FdmQuantoHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmQuantoHelper > * >(argp1);
      arg1 = const_cast< FdmQuantoHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmQuantoHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmQuantoHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdBlackScholesVanillaEngine::CashDividendModel""'");
  } 
  arg8 = static_cast< FdBlackScholesVanillaEngine::CashDividendModel >(val8);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "9"" of type '" "FdBlackScholesVanillaEngine::CashDividendModel""'");
  } 
  arg9 = static_cast< FdBlackScholesVanillaEngine::CashDividendModel >(val9);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "9"" of type '" "FdBlackScholesVanillaEngine::CashDividendModel""'");
  } 
  arg9 = static_cast< FdBlackScholesVanillaEngine::CashDividendModel >(val9);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_22(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_23(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_24(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  bool arg8 ;
  Real arg9 ;
  FdBlackScholesVanillaEngine::CashDividendModel arg10 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "10"" of type '" "FdBlackScholesVanillaEngine::CashDividendModel""'");
  } 
  arg10 = static_cast< FdBlackScholesVanillaEngine::CashDividendModel >(val10);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_25(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  bool arg8 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_26(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  bool arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_27(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_28(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_29(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_30(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine__SWIG_31(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  FdBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdBlackScholesVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdBlackScholesVanillaEngine *)new FdBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesVanillaEngine", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdBlackScholesVanillaEngine__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdBlackScholesVanillaEngine__SWIG_15(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdBlackScholesVanillaEngine__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdBlackScholesVanillaEngine__SWIG_23(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesVanillaEngine__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesVanillaEngine__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdBlackScholesVanillaEngine__SWIG_31(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesVanillaEngine__SWIG_22(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesVanillaEngine__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesVanillaEngine__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesVanillaEngine__SWIG_30(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesVanillaEngine__SWIG_21(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBlackScholesVanillaEngine__SWIG_12(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdBlackScholesVanillaEngine__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBlackScholesVanillaEngine__SWIG_29(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBlackScholesVanillaEngine__SWIG_20(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdBlackScholesVanillaEngine__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdBlackScholesVanillaEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdBlackScholesVanillaEngine__SWIG_28(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdBlackScholesVanillaEngine__SWIG_19(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesVanillaEngine__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesVanillaEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdBlackScholesVanillaEngine__SWIG_27(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesVanillaEngine__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdBlackScholesVanillaEngine__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdBlackScholesVanillaEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdBlackScholesVanillaEngine__SWIG_26(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdBlackScholesVanillaEngine__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdBlackScholesVanillaEngine__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdBlackScholesVanillaEngine__SWIG_25(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdBlackScholesVanillaEngine__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_FdBlackScholesVanillaEngine__SWIG_24(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdBlackScholesVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real,FdBlackScholesVanillaEngine::CashDividendModel)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real,FdBlackScholesVanillaEngine::CashDividendModel)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool,Real,FdBlackScholesVanillaEngine::CashDividendModel)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real,FdBlackScholesVanillaEngine::CashDividendModel)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size)\n"
    "    FdBlackScholesVanillaEngine::FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdBlackScholesVanillaEngine_make(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule const &arg2_defvalue = {
    
  } ;
  DividendSchedule *arg2 = (DividendSchedule *) &arg2_defvalue ;
  ext::shared_ptr< FdmQuantoHelper > const &arg3_defvalue = {
    
  } ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = (ext::shared_ptr< FdmQuantoHelper > *) &arg3_defvalue ;
  Size arg4 = (Size) 100 ;
  Size arg5 = (Size) 100 ;
  Size arg6 = (Size) 0 ;
  FdmSchemeDesc const &arg7_defvalue = FdmSchemeDesc::Douglas() ;
  FdmSchemeDesc *arg7 = (FdmSchemeDesc *) &arg7_defvalue ;
  bool arg8 = (bool) false ;
  Real arg9 = (Real) -Null< Real >() ;
  FdBlackScholesVanillaEngine::CashDividendModel arg10 = (FdBlackScholesVanillaEngine::CashDividendModel) FdBlackScholesVanillaEngine::Spot ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"dividends",  (char *)"quantoHelper",  (char *)"tGrid",  (char *)"xGrid",  (char *)"dampingSteps",  (char *)"schemeDesc",  (char *)"localVol",  (char *)"illegalLocalVolOverwrite",  (char *)"cashDividendModel",  NULL 
  };
  ext::shared_ptr< FdBlackScholesVanillaEngine > result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOO:FdBlackScholesVanillaEngine_make", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
      res2 = swig::asptr(obj1, &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "2"" of type '" "DividendSchedule const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "2"" of type '" "DividendSchedule const &""'"); 
      }
      arg2 = ptr;
    }
  }
  if (obj2) {
    {
      int newmem = 0;
      res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
        delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
        arg3 = &tempshared3;
      } else {
        arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
      }
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_size_t(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "4"" of type '" "Size""'");
    } 
    arg4 = static_cast< Size >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_size_t(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "5"" of type '" "Size""'");
    } 
    arg5 = static_cast< Size >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_size_t(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "6"" of type '" "Size""'");
    } 
    arg6 = static_cast< Size >(val6);
  }
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
    }
    arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_bool(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "8"" of type '" "bool""'");
    } 
    arg8 = static_cast< bool >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_double(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "9"" of type '" "Real""'");
    } 
    arg9 = static_cast< Real >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_int(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "FdBlackScholesVanillaEngine_make" "', argument " "10"" of type '" "FdBlackScholesVanillaEngine::CashDividendModel""'");
    } 
    arg10 = static_cast< FdBlackScholesVanillaEngine::CashDividendModel >(val10);
  }
  {
    try {
      result = FdBlackScholesVanillaEngine_make((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),(FdmSchemeDesc const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesVanillaEngine >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdBlackScholesVanillaEngine *arg1 = (FdBlackScholesVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdBlackScholesVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdBlackScholesVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdBlackScholesVanillaEngine" "', argument " "1"" of type '" "FdBlackScholesVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdBlackScholesVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdBlackScholesVanillaEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdBlackScholesVanillaEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdBlackScholesVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdBlackScholesVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesShoutEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesShoutEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesShoutEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesShoutEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdBlackScholesShoutEngine *)new FdBlackScholesShoutEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesShoutEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesShoutEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesShoutEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesShoutEngine", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdBlackScholesShoutEngine__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdBlackScholesShoutEngine__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdBlackScholesShoutEngine__SWIG_9(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesShoutEngine__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesShoutEngine__SWIG_8(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesShoutEngine__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesShoutEngine__SWIG_7(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdBlackScholesShoutEngine__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBlackScholesShoutEngine__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdBlackScholesShoutEngine__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdBlackScholesShoutEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size)\n"
    "    FdBlackScholesShoutEngine::FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesShoutEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdBlackScholesShoutEngine *arg1 = (FdBlackScholesShoutEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdBlackScholesShoutEngine > tempshared1 ;
  ext::shared_ptr< FdBlackScholesShoutEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdBlackScholesShoutEngine" "', argument " "1"" of type '" "FdBlackScholesShoutEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdBlackScholesShoutEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdBlackScholesShoutEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesShoutEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdBlackScholesShoutEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesShoutEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdBlackScholesShoutEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesShoutEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdBlackScholesShoutEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  DividendSchedule arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  FdOrnsteinUhlenbeckVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdOrnsteinUhlenbeckVanillaEngine *)new FdOrnsteinUhlenbeckVanillaEngine((ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdOrnsteinUhlenbeckVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdOrnsteinUhlenbeckVanillaEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_9(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_7(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FdOrnsteinUhlenbeckVanillaEngine__SWIG_6(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdOrnsteinUhlenbeckVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size,Size,Real,FdmSchemeDesc const &)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size,Size,Real)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size,Size)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,DividendSchedule,Size,Size,Size,Real,FdmSchemeDesc const &)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,DividendSchedule,Size,Size,Size,Real)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,DividendSchedule,Size,Size)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,DividendSchedule,Size)\n"
    "    FdOrnsteinUhlenbeckVanillaEngine::FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdOrnsteinUhlenbeckVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdOrnsteinUhlenbeckVanillaEngine *arg1 = (FdOrnsteinUhlenbeckVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdOrnsteinUhlenbeckVanillaEngine" "', argument " "1"" of type '" "FdOrnsteinUhlenbeckVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > * >(argp1);
      arg1 = const_cast< FdOrnsteinUhlenbeckVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdOrnsteinUhlenbeckVanillaEngine > * >(argp1);
      arg1 = const_cast< FdOrnsteinUhlenbeckVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdOrnsteinUhlenbeckVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdOrnsteinUhlenbeckVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  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 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBatesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBatesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBatesVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBatesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBatesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBatesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdBatesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBatesVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBatesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBatesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBatesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBatesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBatesVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BatesModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BatesModel > tempshared1 ;
  FdBatesVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBatesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< BatesModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BatesModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBatesVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdBatesVanillaEngine *)new FdBatesVanillaEngine((ext::shared_ptr< BatesModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBatesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdBatesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBatesVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBatesVanillaEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdBatesVanillaEngine__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdBatesVanillaEngine__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdBatesVanillaEngine__SWIG_11(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBatesVanillaEngine__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBatesVanillaEngine__SWIG_10(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBatesVanillaEngine__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBatesVanillaEngine__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBatesVanillaEngine__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBatesVanillaEngine__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdBatesVanillaEngine__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdBatesVanillaEngine__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BatesModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdBatesVanillaEngine__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdBatesVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,Size,Size,Size,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,Size,Size,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,Size,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,DividendSchedule,Size,Size,Size,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,DividendSchedule,Size,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,DividendSchedule,Size)\n"
    "    FdBatesVanillaEngine::FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBatesVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdBatesVanillaEngine *arg1 = (FdBatesVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdBatesVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdBatesVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdBatesVanillaEngine" "', argument " "1"" of type '" "FdBatesVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdBatesVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdBatesVanillaEngine > * >(argp1);
      arg1 = const_cast< FdBatesVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdBatesVanillaEngine > * >(argp1);
      arg1 = const_cast< FdBatesVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdBatesVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdBatesVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdBatesVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  double val8 ;
  int ecode8 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonVanillaEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 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 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared2 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< FdmQuantoHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonVanillaEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_22(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_23(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_24(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg9 = 0 ;
  Real arg10 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared9 ;
  double val10 ;
  int ecode10 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FdHestonVanillaEngine" "', argument " "9"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9) : &tempshared9;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdHestonVanillaEngine" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8,(ext::shared_ptr< LocalVolTermStructure > const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_25(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg9 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared9 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FdHestonVanillaEngine" "', argument " "9"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9) : &tempshared9;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8,(ext::shared_ptr< LocalVolTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_26(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_27(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_28(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_29(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_30(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine__SWIG_31(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  FdHestonVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonVanillaEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdHestonVanillaEngine" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdHestonVanillaEngine *)new FdHestonVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonVanillaEngine", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdHestonVanillaEngine__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdHestonVanillaEngine__SWIG_15(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdHestonVanillaEngine__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdHestonVanillaEngine__SWIG_23(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonVanillaEngine__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonVanillaEngine__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdHestonVanillaEngine__SWIG_31(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonVanillaEngine__SWIG_22(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonVanillaEngine__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonVanillaEngine__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonVanillaEngine__SWIG_30(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonVanillaEngine__SWIG_21(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonVanillaEngine__SWIG_12(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonVanillaEngine__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonVanillaEngine__SWIG_29(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonVanillaEngine__SWIG_20(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonVanillaEngine__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdHestonVanillaEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonVanillaEngine__SWIG_28(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonVanillaEngine__SWIG_19(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonVanillaEngine__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonVanillaEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdHestonVanillaEngine__SWIG_27(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonVanillaEngine__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FdHestonVanillaEngine__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdHestonVanillaEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FdHestonVanillaEngine__SWIG_26(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FdHestonVanillaEngine__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdHestonVanillaEngine__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_FdHestonVanillaEngine__SWIG_25(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdHestonVanillaEngine__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_FdHestonVanillaEngine__SWIG_24(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdHestonVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< FdmQuantoHelper > const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &,Size)\n"
    "    FdHestonVanillaEngine::FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,ext::shared_ptr< FdmQuantoHelper > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdHestonVanillaEngine_make(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule const &arg2_defvalue = {
    
  } ;
  DividendSchedule *arg2 = (DividendSchedule *) &arg2_defvalue ;
  ext::shared_ptr< FdmQuantoHelper > const &arg3_defvalue = {
    
  } ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = (ext::shared_ptr< FdmQuantoHelper > *) &arg3_defvalue ;
  Size arg4 = (Size) 100 ;
  Size arg5 = (Size) 100 ;
  Size arg6 = (Size) 50 ;
  Size arg7 = (Size) 0 ;
  FdmSchemeDesc const &arg8_defvalue = FdmSchemeDesc::Hundsdorfer() ;
  FdmSchemeDesc *arg8 = (FdmSchemeDesc *) &arg8_defvalue ;
  ext::shared_ptr< LocalVolTermStructure > const &arg9_defvalue = {
    
  } ;
  ext::shared_ptr< LocalVolTermStructure > *arg9 = (ext::shared_ptr< LocalVolTermStructure > *) &arg9_defvalue ;
  Real arg10 = (Real) (Real)1.0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared9 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"model",  (char *)"dividends",  (char *)"quantoHelper",  (char *)"tGrid",  (char *)"xGrid",  (char *)"vGrid",  (char *)"dampingSteps",  (char *)"schemeDesc",  (char *)"leverageFct",  (char *)"mixingFactor",  NULL 
  };
  ext::shared_ptr< FdHestonVanillaEngine > result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOO:FdHestonVanillaEngine_make", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdHestonVanillaEngine_make" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
      res2 = swig::asptr(obj1, &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdHestonVanillaEngine_make" "', argument " "2"" of type '" "DividendSchedule const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdHestonVanillaEngine_make" "', argument " "2"" of type '" "DividendSchedule const &""'"); 
      }
      arg2 = ptr;
    }
  }
  if (obj2) {
    {
      int newmem = 0;
      res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdHestonVanillaEngine_make" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
        delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
        arg3 = &tempshared3;
      } else {
        arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
      }
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_size_t(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdHestonVanillaEngine_make" "', argument " "4"" of type '" "Size""'");
    } 
    arg4 = static_cast< Size >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_size_t(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FdHestonVanillaEngine_make" "', argument " "5"" of type '" "Size""'");
    } 
    arg5 = static_cast< Size >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_size_t(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FdHestonVanillaEngine_make" "', argument " "6"" of type '" "Size""'");
    } 
    arg6 = static_cast< Size >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_size_t(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FdHestonVanillaEngine_make" "', argument " "7"" of type '" "Size""'");
    } 
    arg7 = static_cast< Size >(val7);
  }
  if (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "FdHestonVanillaEngine_make" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
    }
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdHestonVanillaEngine_make" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
    }
    arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  }
  if (obj8) {
    {
      int newmem = 0;
      res9 = SWIG_ConvertPtrAndOwn(obj8, &argp9, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "FdHestonVanillaEngine_make" "', argument " "9"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9);
        delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9);
        arg9 = &tempshared9;
      } else {
        arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp9) : &tempshared9;
      }
    }
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_double(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "FdHestonVanillaEngine_make" "', argument " "10"" of type '" "Real""'");
    } 
    arg10 = static_cast< Real >(val10);
  }
  {
    try {
      result = FdHestonVanillaEngine_make((ext::shared_ptr< HestonModel > const &)*arg1,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),(FdmSchemeDesc const &)*arg8,(ext::shared_ptr< LocalVolTermStructure > const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonVanillaEngine >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdHestonVanillaEngine *arg1 = (FdHestonVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdHestonVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdHestonVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdHestonVanillaEngine" "', argument " "1"" of type '" "FdHestonVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdHestonVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdHestonVanillaEngine > * >(argp1);
      arg1 = const_cast< FdHestonVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdHestonVanillaEngine > * >(argp1);
      arg1 = const_cast< FdHestonVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdHestonVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdHestonVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdHestonVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticCEVEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  AnalyticCEVEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AnalyticCEVEngine", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AnalyticCEVEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticCEVEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticCEVEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AnalyticCEVEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticCEVEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  {
    try {
      result = (AnalyticCEVEngine *)new AnalyticCEVEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticCEVEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticCEVEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticCEVEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticCEVEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticCEVEngine *arg1 = (AnalyticCEVEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticCEVEngine > tempshared1 ;
  ext::shared_ptr< AnalyticCEVEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticCEVEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticCEVEngine" "', argument " "1"" of type '" "AnalyticCEVEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticCEVEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticCEVEngine > * >(argp1);
      arg1 = const_cast< AnalyticCEVEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticCEVEngine > * >(argp1);
      arg1 = const_cast< AnalyticCEVEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticCEVEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticCEVEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticCEVEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  FdmSchemeDesc *arg10 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdCEVVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdCEVVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdCEVVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdCEVVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdCEVVanillaEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FdCEVVanillaEngine" "', argument " "10"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "10"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg10 = reinterpret_cast< FdmSchemeDesc * >(argp10);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,(FdmSchemeDesc const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdCEVVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdCEVVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdCEVVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdCEVVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdCEVVanillaEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdCEVVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdCEVVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdCEVVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdCEVVanillaEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdCEVVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdCEVVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdCEVVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdCEVVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdCEVVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  Size arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdCEVVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FdCEVVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdCEVVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdCEVVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdCEVVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdCEVVanillaEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  {
    try {
      result = (FdCEVVanillaEngine *)new FdCEVVanillaEngine(arg1,arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdCEVVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdCEVVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdCEVVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdCEVVanillaEngine", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FdCEVVanillaEngine__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdCEVVanillaEngine__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdCEVVanillaEngine__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdCEVVanillaEngine__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdCEVVanillaEngine__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdCEVVanillaEngine__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FdCEVVanillaEngine__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdCEVVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Real,Real,FdmSchemeDesc const &)\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Real,Real)\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Real)\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size)\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size)\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &,Size)\n"
    "    FdCEVVanillaEngine::FdCEVVanillaEngine(Real,Real,Real,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdCEVVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdCEVVanillaEngine *arg1 = (FdCEVVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdCEVVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdCEVVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdCEVVanillaEngine" "', argument " "1"" of type '" "FdCEVVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdCEVVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdCEVVanillaEngine > * >(argp1);
      arg1 = const_cast< FdCEVVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdCEVVanillaEngine > * >(argp1);
      arg1 = const_cast< FdCEVVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdCEVVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdCEVVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdCEVVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  Real arg11 ;
  Real arg12 ;
  FdmSchemeDesc *arg13 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdSabrVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdSabrVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdSabrVanillaEngine" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FdSabrVanillaEngine" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FdSabrVanillaEngine" "', argument " "12"" of type '" "Real""'");
  } 
  arg12 = static_cast< Real >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FdSabrVanillaEngine" "', argument " "13"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "13"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg13 = reinterpret_cast< FdmSchemeDesc * >(argp13);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12,(FdmSchemeDesc const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  Real arg11 ;
  Real arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdSabrVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdSabrVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdSabrVanillaEngine" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FdSabrVanillaEngine" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FdSabrVanillaEngine" "', argument " "12"" of type '" "Real""'");
  } 
  arg12 = static_cast< Real >(val12);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  Real arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdSabrVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdSabrVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdSabrVanillaEngine" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FdSabrVanillaEngine" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  Size arg10 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdSabrVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdSabrVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdSabrVanillaEngine" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdSabrVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdSabrVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  Size 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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdSabrVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Size arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdSabrVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdSabrVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdSabrVanillaEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSabrVanillaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSabrVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSabrVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSabrVanillaEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSabrVanillaEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (FdSabrVanillaEngine *)new FdSabrVanillaEngine(arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSabrVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdSabrVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSabrVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[14] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdSabrVanillaEngine", 0, 13, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdSabrVanillaEngine__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdSabrVanillaEngine__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdSabrVanillaEngine__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdSabrVanillaEngine__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_size_t(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_FdSabrVanillaEngine__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_size_t(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_FdSabrVanillaEngine__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_size_t(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_FdSabrVanillaEngine__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_size_t(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_FdSabrVanillaEngine__SWIG_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdSabrVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Size,Real,Real,FdmSchemeDesc const &)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Size,Real,Real)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Size,Real)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size,Size)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size,Size)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size,Size)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &,Size)\n"
    "    FdSabrVanillaEngine::FdSabrVanillaEngine(Real,Real,Real,Real,Real,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdSabrVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdSabrVanillaEngine *arg1 = (FdSabrVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdSabrVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdSabrVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdSabrVanillaEngine" "', argument " "1"" of type '" "FdSabrVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdSabrVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdSabrVanillaEngine > * >(argp1);
      arg1 = const_cast< FdSabrVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdSabrVanillaEngine > * >(argp1);
      arg1 = const_cast< FdSabrVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdSabrVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdSabrVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdSabrVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  bool arg9 ;
  FdmSchemeDesc *arg10 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "10"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "10"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg10 = reinterpret_cast< FdmSchemeDesc * >(argp10);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(FdmSchemeDesc const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  bool arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  bool arg10 ;
  FdmSchemeDesc *arg11 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "11"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "11"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg11 = reinterpret_cast< FdmSchemeDesc * >(argp11);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(FdmSchemeDesc const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  bool arg10 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  Size arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  Size arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > arg2 ;
  DividendSchedule arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  FdHestonHullWhiteVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "3"" of type '" "DividendSchedule""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonHullWhiteVanillaEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (FdHestonHullWhiteVanillaEngine *)new FdHestonHullWhiteVanillaEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonHullWhiteVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonHullWhiteVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonHullWhiteVanillaEngine", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_15(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_14(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_13(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_12(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_9(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_FdHestonHullWhiteVanillaEngine__SWIG_8(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdHestonHullWhiteVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size,Size,Size,Size,Size,bool,FdmSchemeDesc const &)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size,Size,Size,Size,Size,bool)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size,Size,Size,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size,Size,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,Real)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size,Size,Size,Size,Size,bool,FdmSchemeDesc const &)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size,Size,Size,Size,Size,bool)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size,Size,Size,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size,Size,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real,Size)\n"
    "    FdHestonHullWhiteVanillaEngine::FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhiteProcess >,DividendSchedule,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonHullWhiteVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdHestonHullWhiteVanillaEngine *arg1 = (FdHestonHullWhiteVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdHestonHullWhiteVanillaEngine > tempshared1 ;
  ext::shared_ptr< FdHestonHullWhiteVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdHestonHullWhiteVanillaEngine" "', argument " "1"" of type '" "FdHestonHullWhiteVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > * >(argp1);
      arg1 = const_cast< FdHestonHullWhiteVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdHestonHullWhiteVanillaEngine > * >(argp1);
      arg1 = const_cast< FdHestonHullWhiteVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdHestonHullWhiteVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdHestonHullWhiteVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticHestonHullWhiteEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  AnalyticHestonHullWhiteEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite >""'");
    } else {
      ext::shared_ptr< HullWhite > * temp = reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (AnalyticHestonHullWhiteEngine *)new AnalyticHestonHullWhiteEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonHullWhiteEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonHullWhiteEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonHullWhiteEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  AnalyticHestonHullWhiteEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite >""'");
    } else {
      ext::shared_ptr< HullWhite > * temp = reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (AnalyticHestonHullWhiteEngine *)new AnalyticHestonHullWhiteEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonHullWhiteEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonHullWhiteEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonHullWhiteEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > arg2 ;
  Real arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  AnalyticHestonHullWhiteEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite >""'");
    } else {
      ext::shared_ptr< HullWhite > * temp = reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AnalyticHestonHullWhiteEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (AnalyticHestonHullWhiteEngine *)new AnalyticHestonHullWhiteEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonHullWhiteEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonHullWhiteEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonHullWhiteEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticHestonHullWhiteEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AnalyticHestonHullWhiteEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AnalyticHestonHullWhiteEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_AnalyticHestonHullWhiteEngine__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticHestonHullWhiteEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonHullWhiteEngine::AnalyticHestonHullWhiteEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhite >,Size)\n"
    "    AnalyticHestonHullWhiteEngine::AnalyticHestonHullWhiteEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhite >)\n"
    "    AnalyticHestonHullWhiteEngine::AnalyticHestonHullWhiteEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhite >,Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHestonHullWhiteEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonHullWhiteEngine *arg1 = (AnalyticHestonHullWhiteEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonHullWhiteEngine > tempshared1 ;
  ext::shared_ptr< AnalyticHestonHullWhiteEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticHestonHullWhiteEngine" "', argument " "1"" of type '" "AnalyticHestonHullWhiteEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticHestonHullWhiteEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticHestonHullWhiteEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonHullWhiteEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticHestonHullWhiteEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonHullWhiteEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticHestonHullWhiteEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticHestonHullWhiteEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticH1HWEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  AnalyticH1HWEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticH1HWEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticH1HWEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticH1HWEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'"); 
  }
  arg2 = reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticH1HWEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AnalyticH1HWEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (AnalyticH1HWEngine *)new AnalyticH1HWEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< HullWhite > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticH1HWEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticH1HWEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticH1HWEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticH1HWEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  AnalyticH1HWEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticH1HWEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticH1HWEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticH1HWEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'"); 
  }
  arg2 = reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticH1HWEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AnalyticH1HWEngine *)new AnalyticH1HWEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< HullWhite > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticH1HWEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticH1HWEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticH1HWEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticH1HWEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  AnalyticH1HWEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticH1HWEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticH1HWEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticH1HWEngine" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'"); 
  }
  arg2 = reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticH1HWEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AnalyticH1HWEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AnalyticH1HWEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (AnalyticH1HWEngine *)new AnalyticH1HWEngine((ext::shared_ptr< HestonModel > const &)*arg1,(ext::shared_ptr< HullWhite > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticH1HWEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticH1HWEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticH1HWEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticH1HWEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticH1HWEngine", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AnalyticH1HWEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_AnalyticH1HWEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_AnalyticH1HWEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticH1HWEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticH1HWEngine::AnalyticH1HWEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhite > const &,Real,Size)\n"
    "    AnalyticH1HWEngine::AnalyticH1HWEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhite > const &,Real)\n"
    "    AnalyticH1HWEngine::AnalyticH1HWEngine(ext::shared_ptr< HestonModel > const &,ext::shared_ptr< HullWhite > const &,Real,Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticH1HWEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticH1HWEngine *arg1 = (AnalyticH1HWEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticH1HWEngine > tempshared1 ;
  ext::shared_ptr< AnalyticH1HWEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticH1HWEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticH1HWEngine" "', argument " "1"" of type '" "AnalyticH1HWEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticH1HWEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticH1HWEngine > * >(argp1);
      arg1 = const_cast< AnalyticH1HWEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticH1HWEngine > * >(argp1);
      arg1 = const_cast< AnalyticH1HWEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticH1HWEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticH1HWEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticH1HWEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  ForwardEuropeanEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (ForwardEuropeanEngine *)new ForwardEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  ForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardEuropeanEngine *arg1 = (ForwardEuropeanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardEuropeanEngine > tempshared1 ;
  ext::shared_ptr< ForwardEuropeanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardEuropeanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardEuropeanEngine" "', argument " "1"" of type '" "ForwardEuropeanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ForwardEuropeanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ForwardEuropeanEngine > * >(argp1);
      arg1 = const_cast< ForwardEuropeanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ForwardEuropeanEngine > * >(argp1);
      arg1 = const_cast< ForwardEuropeanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ForwardEuropeanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  QuantoEuropeanEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoEuropeanEngine", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantoEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuantoEuropeanEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoEuropeanEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_QuantoEuropeanEngine" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoEuropeanEngine" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_QuantoEuropeanEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoEuropeanEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (QuantoEuropeanEngine *)new QuantoEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  QuantoEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoEuropeanEngine *arg1 = (QuantoEuropeanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoEuropeanEngine > tempshared1 ;
  ext::shared_ptr< QuantoEuropeanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoEuropeanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoEuropeanEngine" "', argument " "1"" of type '" "QuantoEuropeanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoEuropeanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoEuropeanEngine > * >(argp1);
      arg1 = const_cast< QuantoEuropeanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoEuropeanEngine > * >(argp1);
      arg1 = const_cast< QuantoEuropeanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoEuropeanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoForwardEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< BlackVolTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  QuantoForwardEuropeanEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoForwardEuropeanEngine", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "3"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoForwardEuropeanEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (QuantoForwardEuropeanEngine *)new QuantoForwardEuropeanEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< BlackVolTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoForwardEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  QuantoForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoForwardEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoForwardEuropeanEngine *arg1 = (QuantoForwardEuropeanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoForwardEuropeanEngine > tempshared1 ;
  ext::shared_ptr< QuantoForwardEuropeanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoForwardEuropeanEngine" "', argument " "1"" of type '" "QuantoForwardEuropeanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoForwardEuropeanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoForwardEuropeanEngine > * >(argp1);
      arg1 = const_cast< QuantoForwardEuropeanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoForwardEuropeanEngine > * >(argp1);
      arg1 = const_cast< QuantoForwardEuropeanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoForwardEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoForwardEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticHestonForwardEuropeanEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AnalyticHestonForwardEuropeanEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonForwardEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticHestonForwardEuropeanEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (AnalyticHestonForwardEuropeanEngine *)new AnalyticHestonForwardEuropeanEngine((ext::shared_ptr< HestonProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonForwardEuropeanEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  AnalyticHestonForwardEuropeanEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticHestonForwardEuropeanEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticHestonForwardEuropeanEngine *)new AnalyticHestonForwardEuropeanEngine((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticHestonForwardEuropeanEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticHestonForwardEuropeanEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticHestonForwardEuropeanEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnalyticHestonForwardEuropeanEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticHestonForwardEuropeanEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticHestonForwardEuropeanEngine::AnalyticHestonForwardEuropeanEngine(ext::shared_ptr< HestonProcess > const &,Size)\n"
    "    AnalyticHestonForwardEuropeanEngine::AnalyticHestonForwardEuropeanEngine(ext::shared_ptr< HestonProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticHestonForwardEuropeanEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticHestonForwardEuropeanEngine *arg1 = (AnalyticHestonForwardEuropeanEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticHestonForwardEuropeanEngine > tempshared1 ;
  ext::shared_ptr< AnalyticHestonForwardEuropeanEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticHestonForwardEuropeanEngine" "', argument " "1"" of type '" "AnalyticHestonForwardEuropeanEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonForwardEuropeanEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticHestonForwardEuropeanEngine > * >(argp1);
      arg1 = const_cast< AnalyticHestonForwardEuropeanEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticHestonForwardEuropeanEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticHestonForwardEuropeanEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRForwardEuropeanBSEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCForwardEuropeanBSEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPRForwardEuropeanBSEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRForwardEuropeanBSEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRForwardEuropeanBSEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPRForwardEuropeanBSEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRForwardEuropeanBSEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCForwardEuropeanBSEngine< PseudoRandom > *)new_MCForwardEuropeanBSEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRForwardEuropeanBSEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCForwardEuropeanBSEngine< PseudoRandom > *arg1 = (MCForwardEuropeanBSEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCForwardEuropeanBSEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCForwardEuropeanBSEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRForwardEuropeanBSEngine" "', argument " "1"" of type '" "MCForwardEuropeanBSEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanBSEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanBSEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanBSEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRForwardEuropeanBSEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRForwardEuropeanBSEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDForwardEuropeanBSEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCForwardEuropeanBSEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDForwardEuropeanBSEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDForwardEuropeanBSEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDForwardEuropeanBSEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDForwardEuropeanBSEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDForwardEuropeanBSEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCForwardEuropeanBSEngine< LowDiscrepancy > *)new_MCForwardEuropeanBSEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDForwardEuropeanBSEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCForwardEuropeanBSEngine< LowDiscrepancy > *arg1 = (MCForwardEuropeanBSEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCForwardEuropeanBSEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCForwardEuropeanBSEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDForwardEuropeanBSEngine" "', argument " "1"" of type '" "MCForwardEuropeanBSEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanBSEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanBSEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanBSEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDForwardEuropeanBSEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDForwardEuropeanBSEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRForwardEuropeanHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  bool arg9 = (bool) false ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"controlVariate",  NULL 
  };
  MCForwardEuropeanHestonEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPRForwardEuropeanHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRForwardEuropeanHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRForwardEuropeanHestonEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCPRForwardEuropeanHestonEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRForwardEuropeanHestonEngine" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  {
    try {
      result = (MCForwardEuropeanHestonEngine< PseudoRandom > *)new_MCForwardEuropeanHestonEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRForwardEuropeanHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCForwardEuropeanHestonEngine< PseudoRandom > *arg1 = (MCForwardEuropeanHestonEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCForwardEuropeanHestonEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCForwardEuropeanHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRForwardEuropeanHestonEngine" "', argument " "1"" of type '" "MCForwardEuropeanHestonEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanHestonEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanHestonEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRForwardEuropeanHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRForwardEuropeanHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDForwardEuropeanHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  bool arg9 = (bool) false ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"controlVariate",  NULL 
  };
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDForwardEuropeanHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDForwardEuropeanHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDForwardEuropeanHestonEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCLDForwardEuropeanHestonEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDForwardEuropeanHestonEngine" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  {
    try {
      result = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *)new_MCForwardEuropeanHestonEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDForwardEuropeanHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCForwardEuropeanHestonEngine< LowDiscrepancy > *arg1 = (MCForwardEuropeanHestonEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCForwardEuropeanHestonEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCForwardEuropeanHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDForwardEuropeanHestonEngine" "', argument " "1"" of type '" "MCForwardEuropeanHestonEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanHestonEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCForwardEuropeanHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCForwardEuropeanHestonEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDForwardEuropeanHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDForwardEuropeanHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackCalculator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  BlackCalculator *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCalculator" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackCalculator" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackCalculator" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BlackCalculator" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (BlackCalculator *)new BlackCalculator((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlackCalculator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCalculator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  BlackCalculator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCalculator" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackCalculator" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackCalculator" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (BlackCalculator *)new BlackCalculator((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlackCalculator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCalculator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackCalculator", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BlackCalculator__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_BlackCalculator__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackCalculator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackCalculator::BlackCalculator(ext::shared_ptr< StrikedTypePayoff > const &,Real,Real,Real)\n"
    "    BlackCalculator::BlackCalculator(ext::shared_ptr< StrikedTypePayoff > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_value" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->value();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_deltaForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_deltaForward" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->deltaForward();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_delta", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_delta" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_delta" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->delta(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_elasticityForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_elasticityForward" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->elasticityForward();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_elasticity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_elasticity", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_elasticity" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_elasticity" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->elasticity(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_gammaForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_gammaForward" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->gammaForward();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_gamma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_gamma", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_gamma" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_gamma" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->gamma(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_theta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_theta", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_theta" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_theta" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalculator_theta" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->theta(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_thetaPerDay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_thetaPerDay", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_thetaPerDay" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_thetaPerDay" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalculator_thetaPerDay" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->thetaPerDay(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_vega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_vega", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_vega" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_vega" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->vega(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_rho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_rho", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_rho" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_rho" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->rho(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_dividendRho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalculator_dividendRho", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_dividendRho" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalculator_dividendRho" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->dividendRho(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_itmCashProbability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_itmCashProbability" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->itmCashProbability();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_itmAssetProbability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_itmAssetProbability" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->itmAssetProbability();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_strikeSensitivity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_strikeSensitivity" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->strikeSensitivity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_strikeGamma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_strikeGamma" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->strikeGamma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_alpha" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalculator_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalculator_beta" "', argument " "1"" of type '" "BlackCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      result = (Real)((BlackCalculator const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalculator *arg1 = (BlackCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackCalculator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackCalculator" "', argument " "1"" of type '" "BlackCalculator *""'"); 
  }
  arg1 = reinterpret_cast< BlackCalculator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BlackCalculator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VarianceGammaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VarianceGammaProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< VarianceGammaProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  VarianceGammaEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VarianceGammaEngine" "', argument " "1"" of type '" "ext::shared_ptr< VarianceGammaProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (VarianceGammaEngine *)new VarianceGammaEngine((ext::shared_ptr< VarianceGammaProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VarianceGammaEngine > *smartresult = result ? new ext::shared_ptr<  VarianceGammaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VarianceGammaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VarianceGammaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VarianceGammaEngine *arg1 = (VarianceGammaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VarianceGammaEngine > tempshared1 ;
  ext::shared_ptr< VarianceGammaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VarianceGammaEngine" "', argument " "1"" of type '" "VarianceGammaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VarianceGammaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VarianceGammaEngine > * >(argp1);
      arg1 = const_cast< VarianceGammaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VarianceGammaEngine > * >(argp1);
      arg1 = const_cast< VarianceGammaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VarianceGammaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VarianceGammaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VarianceGammaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FFTVarianceGammaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VarianceGammaProcess > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< VarianceGammaProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  FFTVarianceGammaEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FFTVarianceGammaEngine" "', argument " "1"" of type '" "ext::shared_ptr< VarianceGammaProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FFTVarianceGammaEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (FFTVarianceGammaEngine *)new FFTVarianceGammaEngine((ext::shared_ptr< VarianceGammaProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FFTVarianceGammaEngine > *smartresult = result ? new ext::shared_ptr<  FFTVarianceGammaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FFTVarianceGammaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FFTVarianceGammaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VarianceGammaProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< VarianceGammaProcess > tempshared1 ;
  FFTVarianceGammaEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FFTVarianceGammaEngine" "', argument " "1"" of type '" "ext::shared_ptr< VarianceGammaProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< VarianceGammaProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FFTVarianceGammaEngine *)new FFTVarianceGammaEngine((ext::shared_ptr< VarianceGammaProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FFTVarianceGammaEngine > *smartresult = result ? new ext::shared_ptr<  FFTVarianceGammaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FFTVarianceGammaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FFTVarianceGammaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FFTVarianceGammaEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FFTVarianceGammaEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VarianceGammaProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FFTVarianceGammaEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FFTVarianceGammaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FFTVarianceGammaEngine::FFTVarianceGammaEngine(ext::shared_ptr< VarianceGammaProcess > const &,Real)\n"
    "    FFTVarianceGammaEngine::FFTVarianceGammaEngine(ext::shared_ptr< VarianceGammaProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FFTVarianceGammaEngine_precalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FFTVarianceGammaEngine *arg1 = (FFTVarianceGammaEngine *) 0 ;
  std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FFTVarianceGammaEngine > tempshared1 ;
  ext::shared_ptr< FFTVarianceGammaEngine > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FFTVarianceGammaEngine_precalculate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FFTVarianceGammaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FFTVarianceGammaEngine_precalculate" "', argument " "1"" of type '" "FFTVarianceGammaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FFTVarianceGammaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FFTVarianceGammaEngine > * >(argp1);
      arg1 = const_cast< FFTVarianceGammaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FFTVarianceGammaEngine > * >(argp1);
      arg1 = const_cast< FFTVarianceGammaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *ptr = (std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FFTVarianceGammaEngine_precalculate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FFTVarianceGammaEngine_precalculate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->precalculate((std::vector< ext::shared_ptr< Instrument >,std::allocator< ext::shared_ptr< Instrument > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FFTVarianceGammaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FFTVarianceGammaEngine *arg1 = (FFTVarianceGammaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FFTVarianceGammaEngine > tempshared1 ;
  ext::shared_ptr< FFTVarianceGammaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FFTVarianceGammaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FFTVarianceGammaEngine" "', argument " "1"" of type '" "FFTVarianceGammaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FFTVarianceGammaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FFTVarianceGammaEngine > * >(argp1);
      arg1 = const_cast< FFTVarianceGammaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FFTVarianceGammaEngine > * >(argp1);
      arg1 = const_cast< FFTVarianceGammaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FFTVarianceGammaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FFTVarianceGammaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FFTVarianceGammaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GJRGARCHModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  GJRGARCHModel *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GJRGARCHModel" "', argument " "1"" of type '" "ext::shared_ptr< GJRGARCHProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (GJRGARCHModel *)new GJRGARCHModel((ext::shared_ptr< GJRGARCHProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GJRGARCHModel > *smartresult = result ? new ext::shared_ptr<  GJRGARCHModel >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHModel_omega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel const > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHModel_omega" "', argument " "1"" of type '" "GJRGARCHModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->omega();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHModel_alpha(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel const > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHModel_alpha" "', argument " "1"" of type '" "GJRGARCHModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->alpha();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHModel_beta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel const > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHModel_beta" "', argument " "1"" of type '" "GJRGARCHModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->beta();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHModel_gamma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel const > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHModel_gamma" "', argument " "1"" of type '" "GJRGARCHModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->gamma();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHModel_lambda_parameter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel const > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHModel_lambda_parameter" "', argument " "1"" of type '" "GJRGARCHModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->lambda();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GJRGARCHModel_v0(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel const > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GJRGARCHModel_v0" "', argument " "1"" of type '" "GJRGARCHModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((GJRGARCHModel const *)arg1)->v0();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GJRGARCHModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GJRGARCHModel *arg1 = (GJRGARCHModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel > tempshared1 ;
  ext::shared_ptr< GJRGARCHModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GJRGARCHModel" "', argument " "1"" of type '" "GJRGARCHModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GJRGARCHModel > * >(argp1);
      arg1 = const_cast< GJRGARCHModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GJRGARCHModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GJRGARCHModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticGJRGARCHEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GJRGARCHModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHModel > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticGJRGARCHEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticGJRGARCHEngine" "', argument " "1"" of type '" "ext::shared_ptr< GJRGARCHModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GJRGARCHModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GJRGARCHModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GJRGARCHModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticGJRGARCHEngine *)new AnalyticGJRGARCHEngine((ext::shared_ptr< GJRGARCHModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticGJRGARCHEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticGJRGARCHEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticGJRGARCHEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticGJRGARCHEngine *arg1 = (AnalyticGJRGARCHEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticGJRGARCHEngine > tempshared1 ;
  ext::shared_ptr< AnalyticGJRGARCHEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticGJRGARCHEngine" "', argument " "1"" of type '" "AnalyticGJRGARCHEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticGJRGARCHEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticGJRGARCHEngine > * >(argp1);
      arg1 = const_cast< AnalyticGJRGARCHEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticGJRGARCHEngine > * >(argp1);
      arg1 = const_cast< AnalyticGJRGARCHEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticGJRGARCHEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticGJRGARCHEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPREuropeanGJRGARCHEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanGJRGARCHEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCPREuropeanGJRGARCHEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPREuropeanGJRGARCHEngine" "', argument " "1"" of type '" "ext::shared_ptr< GJRGARCHProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPREuropeanGJRGARCHEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCPREuropeanGJRGARCHEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< PseudoRandom > *)new_MCEuropeanGJRGARCHEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GJRGARCHProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPREuropeanGJRGARCHEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanGJRGARCHEngine< PseudoRandom > *arg1 = (MCEuropeanGJRGARCHEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPREuropeanGJRGARCHEngine" "', argument " "1"" of type '" "MCEuropeanGJRGARCHEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanGJRGARCHEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanGJRGARCHEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanGJRGARCHEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPREuropeanGJRGARCHEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPREuropeanGJRGARCHEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDEuropeanGJRGARCHEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GJRGARCHProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GJRGARCHProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCLDEuropeanGJRGARCHEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GJRGARCHProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDEuropeanGJRGARCHEngine" "', argument " "1"" of type '" "ext::shared_ptr< GJRGARCHProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GJRGARCHProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDEuropeanGJRGARCHEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCLDEuropeanGJRGARCHEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  {
    try {
      result = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *)new_MCEuropeanGJRGARCHEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GJRGARCHProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDEuropeanGJRGARCHEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanGJRGARCHEngine< LowDiscrepancy > *arg1 = (MCEuropeanGJRGARCHEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDEuropeanGJRGARCHEngine" "', argument " "1"" of type '" "MCEuropeanGJRGARCHEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanGJRGARCHEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanGJRGARCHEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanGJRGARCHEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDEuropeanGJRGARCHEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDEuropeanGJRGARCHEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MargrabeOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Integer arg2 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  MargrabeOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MargrabeOption", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MargrabeOption" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MargrabeOption" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MargrabeOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (MargrabeOption *)new MargrabeOption(arg1,arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MargrabeOption > *smartresult = result ? new ext::shared_ptr<  MargrabeOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MargrabeOption_delta1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MargrabeOption const > tempshared1 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MargrabeOption_delta1" "', argument " "1"" of type '" "MargrabeOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->delta1();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MargrabeOption_delta2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MargrabeOption const > tempshared1 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MargrabeOption_delta2" "', argument " "1"" of type '" "MargrabeOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->delta2();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MargrabeOption_gamma1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MargrabeOption const > tempshared1 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MargrabeOption_gamma1" "', argument " "1"" of type '" "MargrabeOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->gamma1();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MargrabeOption_gamma2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MargrabeOption const > tempshared1 ;
  ext::shared_ptr< MargrabeOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MargrabeOption_gamma2" "', argument " "1"" of type '" "MargrabeOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((MargrabeOption const *)arg1)->gamma2();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MargrabeOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MargrabeOption *arg1 = (MargrabeOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MargrabeOption > tempshared1 ;
  ext::shared_ptr< MargrabeOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MargrabeOption" "', argument " "1"" of type '" "MargrabeOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MargrabeOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MargrabeOption > * >(argp1);
      arg1 = const_cast< MargrabeOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MargrabeOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MargrabeOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MargrabeOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticEuropeanMargrabeEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  AnalyticEuropeanMargrabeEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AnalyticEuropeanMargrabeEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticEuropeanMargrabeEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticEuropeanMargrabeEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticEuropeanMargrabeEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AnalyticEuropeanMargrabeEngine *)new AnalyticEuropeanMargrabeEngine(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticEuropeanMargrabeEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticEuropeanMargrabeEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanMargrabeEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticEuropeanMargrabeEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticEuropeanMargrabeEngine *arg1 = (AnalyticEuropeanMargrabeEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticEuropeanMargrabeEngine > tempshared1 ;
  ext::shared_ptr< AnalyticEuropeanMargrabeEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanMargrabeEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticEuropeanMargrabeEngine" "', argument " "1"" of type '" "AnalyticEuropeanMargrabeEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticEuropeanMargrabeEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticEuropeanMargrabeEngine > * >(argp1);
      arg1 = const_cast< AnalyticEuropeanMargrabeEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticEuropeanMargrabeEngine > * >(argp1);
      arg1 = const_cast< AnalyticEuropeanMargrabeEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticEuropeanMargrabeEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticEuropeanMargrabeEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticEuropeanMargrabeEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticAmericanMargrabeEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  AnalyticAmericanMargrabeEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AnalyticAmericanMargrabeEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticAmericanMargrabeEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticAmericanMargrabeEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticAmericanMargrabeEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AnalyticAmericanMargrabeEngine *)new AnalyticAmericanMargrabeEngine(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticAmericanMargrabeEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticAmericanMargrabeEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticAmericanMargrabeEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticAmericanMargrabeEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticAmericanMargrabeEngine *arg1 = (AnalyticAmericanMargrabeEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticAmericanMargrabeEngine > tempshared1 ;
  ext::shared_ptr< AnalyticAmericanMargrabeEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticAmericanMargrabeEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticAmericanMargrabeEngine" "', argument " "1"" of type '" "AnalyticAmericanMargrabeEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticAmericanMargrabeEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticAmericanMargrabeEngine > * >(argp1);
      arg1 = const_cast< AnalyticAmericanMargrabeEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticAmericanMargrabeEngine > * >(argp1);
      arg1 = const_cast< AnalyticAmericanMargrabeEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticAmericanMargrabeEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticAmericanMargrabeEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticAmericanMargrabeEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CompoundOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrikedTypePayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > arg3 ;
  ext::shared_ptr< Exercise > arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  CompoundOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CompoundOption", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompoundOption" "', argument " "1"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompoundOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CompoundOption" "', argument " "3"" of type '" "ext::shared_ptr< StrikedTypePayoff >""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CompoundOption" "', argument " "4"" of type '" "ext::shared_ptr< Exercise >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
  }
  {
    try {
      result = (CompoundOption *)new CompoundOption((ext::shared_ptr< StrikedTypePayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CompoundOption > *smartresult = result ? new ext::shared_ptr<  CompoundOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CompoundOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CompoundOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CompoundOption *arg1 = (CompoundOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CompoundOption > tempshared1 ;
  ext::shared_ptr< CompoundOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CompoundOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompoundOption" "', argument " "1"" of type '" "CompoundOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CompoundOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CompoundOption > * >(argp1);
      arg1 = const_cast< CompoundOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CompoundOption > * >(argp1);
      arg1 = const_cast< CompoundOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CompoundOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CompoundOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CompoundOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticCompoundOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AnalyticCompoundOptionEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticCompoundOptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    try {
      result = (AnalyticCompoundOptionEngine *)new AnalyticCompoundOptionEngine(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticCompoundOptionEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticCompoundOptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticCompoundOptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticCompoundOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticCompoundOptionEngine *arg1 = (AnalyticCompoundOptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticCompoundOptionEngine > tempshared1 ;
  ext::shared_ptr< AnalyticCompoundOptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticCompoundOptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticCompoundOptionEngine" "', argument " "1"" of type '" "AnalyticCompoundOptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticCompoundOptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticCompoundOptionEngine > * >(argp1);
      arg1 = const_cast< AnalyticCompoundOptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticCompoundOptionEngine > * >(argp1);
      arg1 = const_cast< AnalyticCompoundOptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticCompoundOptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticCompoundOptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticCompoundOptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SimpleChooserOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date arg1 ;
  Real arg2 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  SimpleChooserOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SimpleChooserOption", 3, 3, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SimpleChooserOption" "', argument " "1"" of type '" "Date""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SimpleChooserOption" "', argument " "1"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SimpleChooserOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SimpleChooserOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (SimpleChooserOption *)new SimpleChooserOption(arg1,arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SimpleChooserOption > *smartresult = result ? new ext::shared_ptr<  SimpleChooserOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SimpleChooserOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SimpleChooserOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpleChooserOption *arg1 = (SimpleChooserOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SimpleChooserOption > tempshared1 ;
  ext::shared_ptr< SimpleChooserOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SimpleChooserOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleChooserOption" "', argument " "1"" of type '" "SimpleChooserOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SimpleChooserOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SimpleChooserOption > * >(argp1);
      arg1 = const_cast< SimpleChooserOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SimpleChooserOption > * >(argp1);
      arg1 = const_cast< SimpleChooserOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SimpleChooserOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SimpleChooserOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SimpleChooserOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticSimpleChooserEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AnalyticSimpleChooserEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticSimpleChooserEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    try {
      result = (AnalyticSimpleChooserEngine *)new AnalyticSimpleChooserEngine(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticSimpleChooserEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticSimpleChooserEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticSimpleChooserEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticSimpleChooserEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticSimpleChooserEngine *arg1 = (AnalyticSimpleChooserEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticSimpleChooserEngine > tempshared1 ;
  ext::shared_ptr< AnalyticSimpleChooserEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticSimpleChooserEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticSimpleChooserEngine" "', argument " "1"" of type '" "AnalyticSimpleChooserEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticSimpleChooserEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticSimpleChooserEngine > * >(argp1);
      arg1 = const_cast< AnalyticSimpleChooserEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticSimpleChooserEngine > * >(argp1);
      arg1 = const_cast< AnalyticSimpleChooserEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticSimpleChooserEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticSimpleChooserEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticSimpleChooserEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ComplexChooserOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< Exercise > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< Exercise > tempshared5 ;
  PyObject *swig_obj[5] ;
  ComplexChooserOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ComplexChooserOption", 5, 5, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexChooserOption" "', argument " "1"" of type '" "Date""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexChooserOption" "', argument " "1"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ComplexChooserOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexChooserOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ComplexChooserOption" "', argument " "4"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ComplexChooserOption" "', argument " "5"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (ComplexChooserOption *)new ComplexChooserOption(arg1,arg2,arg3,(ext::shared_ptr< Exercise > const &)*arg4,(ext::shared_ptr< Exercise > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ComplexChooserOption > *smartresult = result ? new ext::shared_ptr<  ComplexChooserOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ComplexChooserOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ComplexChooserOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ComplexChooserOption *arg1 = (ComplexChooserOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ComplexChooserOption > tempshared1 ;
  ext::shared_ptr< ComplexChooserOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ComplexChooserOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexChooserOption" "', argument " "1"" of type '" "ComplexChooserOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ComplexChooserOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ComplexChooserOption > * >(argp1);
      arg1 = const_cast< ComplexChooserOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ComplexChooserOption > * >(argp1);
      arg1 = const_cast< ComplexChooserOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexChooserOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ComplexChooserOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ComplexChooserOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticComplexChooserEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AnalyticComplexChooserEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticComplexChooserEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    try {
      result = (AnalyticComplexChooserEngine *)new AnalyticComplexChooserEngine(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticComplexChooserEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticComplexChooserEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticComplexChooserEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticComplexChooserEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticComplexChooserEngine *arg1 = (AnalyticComplexChooserEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticComplexChooserEngine > tempshared1 ;
  ext::shared_ptr< AnalyticComplexChooserEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticComplexChooserEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticComplexChooserEngine" "', argument " "1"" of type '" "AnalyticComplexChooserEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticComplexChooserEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticComplexChooserEngine > * >(argp1);
      arg1 = const_cast< AnalyticComplexChooserEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticComplexChooserEngine > * >(argp1);
      arg1 = const_cast< AnalyticComplexChooserEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticComplexChooserEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticComplexChooserEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticComplexChooserEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Average *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Average", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Average *)new Average();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Average, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Average(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Average *arg1 = (Average *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Average, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Average" "', argument " "1"" of type '" "Average *""'"); 
  }
  arg1 = reinterpret_cast< Average * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Average_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Average, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Average_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ContinuousAveragingAsianOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Average::Type arg1 ;
  ext::shared_ptr< StrikedTypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  ContinuousAveragingAsianOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ContinuousAveragingAsianOption", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContinuousAveragingAsianOption" "', argument " "1"" of type '" "Average::Type""'");
  } 
  arg1 = static_cast< Average::Type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContinuousAveragingAsianOption" "', argument " "2"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ContinuousAveragingAsianOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (ContinuousAveragingAsianOption *)new ContinuousAveragingAsianOption(arg1,(ext::shared_ptr< StrikedTypePayoff > const &)*arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ContinuousAveragingAsianOption > *smartresult = result ? new ext::shared_ptr<  ContinuousAveragingAsianOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ContinuousAveragingAsianOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ContinuousAveragingAsianOption *arg1 = (ContinuousAveragingAsianOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ContinuousAveragingAsianOption > tempshared1 ;
  ext::shared_ptr< ContinuousAveragingAsianOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContinuousAveragingAsianOption" "', argument " "1"" of type '" "ContinuousAveragingAsianOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ContinuousAveragingAsianOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ContinuousAveragingAsianOption > * >(argp1);
      arg1 = const_cast< ContinuousAveragingAsianOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ContinuousAveragingAsianOption > * >(argp1);
      arg1 = const_cast< ContinuousAveragingAsianOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContinuousAveragingAsianOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ContinuousAveragingAsianOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ContinuousAveragingAsianOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DiscreteAveragingAsianOption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Average::Type arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< Date,std::allocator< Date > > arg4 ;
  ext::shared_ptr< StrikedTypePayoff > *arg5 = 0 ;
  ext::shared_ptr< Exercise > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< Exercise > tempshared6 ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "1"" of type '" "Average::Type""'");
  } 
  arg1 = static_cast< Average::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    int res = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "4"" of type '" "std::vector< Date,std::allocator< Date > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "5"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5) : &tempshared5;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "6"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (DiscreteAveragingAsianOption *)new DiscreteAveragingAsianOption(arg1,arg2,arg3,arg4,(ext::shared_ptr< StrikedTypePayoff > const &)*arg5,(ext::shared_ptr< Exercise > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscreteAveragingAsianOption > *smartresult = result ? new ext::shared_ptr<  DiscreteAveragingAsianOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscreteAveragingAsianOption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Average::Type arg1 ;
  std::vector< Date,std::allocator< Date > > arg2 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< Exercise > tempshared4 ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "1"" of type '" "Average::Type""'");
  } 
  arg1 = static_cast< Average::Type >(val1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "3"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "4"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4) : &tempshared4;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (DiscreteAveragingAsianOption *)new DiscreteAveragingAsianOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::shared_ptr< Exercise > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscreteAveragingAsianOption > *smartresult = result ? new ext::shared_ptr<  DiscreteAveragingAsianOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscreteAveragingAsianOption__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Average::Type arg1 ;
  std::vector< Date,std::allocator< Date > > arg2 ;
  ext::shared_ptr< StrikedTypePayoff > *arg3 = 0 ;
  ext::shared_ptr< Exercise > *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< Exercise > tempshared4 ;
  DiscreteAveragingAsianOption *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "1"" of type '" "Average::Type""'");
  } 
  arg1 = static_cast< Average::Type >(val1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "3"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DiscreteAveragingAsianOption" "', argument " "4"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (DiscreteAveragingAsianOption *)new DiscreteAveragingAsianOption(arg1,arg2,(ext::shared_ptr< StrikedTypePayoff > const &)*arg3,(ext::shared_ptr< Exercise > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscreteAveragingAsianOption > *smartresult = result ? new ext::shared_ptr<  DiscreteAveragingAsianOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscreteAveragingAsianOption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiscreteAveragingAsianOption", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_DiscreteAveragingAsianOption__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_DiscreteAveragingAsianOption__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Date,std::allocator< Date > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_DiscreteAveragingAsianOption__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiscreteAveragingAsianOption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DiscreteAveragingAsianOption::DiscreteAveragingAsianOption(Average::Type,Real,Size,std::vector< Date,std::allocator< Date > >,ext::shared_ptr< StrikedTypePayoff > const &,ext::shared_ptr< Exercise > const &)\n"
    "    DiscreteAveragingAsianOption::DiscreteAveragingAsianOption(Average::Type,std::vector< Date,std::allocator< Date > >,ext::shared_ptr< StrikedTypePayoff > const &,ext::shared_ptr< Exercise > const &,std::vector< Real,std::allocator< Real > >)\n"
    "    DiscreteAveragingAsianOption::DiscreteAveragingAsianOption(Average::Type,std::vector< Date,std::allocator< Date > >,ext::shared_ptr< StrikedTypePayoff > const &,ext::shared_ptr< Exercise > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiscreteAveragingAsianOption_timeGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DiscreteAveragingAsianOption *arg1 = (DiscreteAveragingAsianOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DiscreteAveragingAsianOption > tempshared1 ;
  ext::shared_ptr< DiscreteAveragingAsianOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeGrid result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteAveragingAsianOption_timeGrid" "', argument " "1"" of type '" "DiscreteAveragingAsianOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DiscreteAveragingAsianOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DiscreteAveragingAsianOption > * >(argp1);
      arg1 = const_cast< DiscreteAveragingAsianOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DiscreteAveragingAsianOption > * >(argp1);
      arg1 = const_cast< DiscreteAveragingAsianOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = DiscreteAveragingAsianOption_timeGrid(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeGrid(result)), SWIGTYPE_p_TimeGrid, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DiscreteAveragingAsianOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DiscreteAveragingAsianOption *arg1 = (DiscreteAveragingAsianOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DiscreteAveragingAsianOption > tempshared1 ;
  ext::shared_ptr< DiscreteAveragingAsianOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteAveragingAsianOption" "', argument " "1"" of type '" "DiscreteAveragingAsianOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DiscreteAveragingAsianOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DiscreteAveragingAsianOption > * >(argp1);
      arg1 = const_cast< DiscreteAveragingAsianOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DiscreteAveragingAsianOption > * >(argp1);
      arg1 = const_cast< DiscreteAveragingAsianOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscreteAveragingAsianOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DiscreteAveragingAsianOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiscreteAveragingAsianOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticContinuousGeometricAveragePriceAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticContinuousGeometricAveragePriceAsianEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianEngine *)new AnalyticContinuousGeometricAveragePriceAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticContinuousGeometricAveragePriceAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticContinuousGeometricAveragePriceAsianEngine *arg1 = (AnalyticContinuousGeometricAveragePriceAsianEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > tempshared1 ;
  ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticContinuousGeometricAveragePriceAsianEngine" "', argument " "1"" of type '" "AnalyticContinuousGeometricAveragePriceAsianEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousGeometricAveragePriceAsianEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousGeometricAveragePriceAsianEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)new AnalyticContinuousGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)new AnalyticContinuousGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *)new AnalyticContinuousGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticContinuousGeometricAveragePriceAsianHestonEngine::AnalyticContinuousGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const &,Size,Real)\n"
    "    AnalyticContinuousGeometricAveragePriceAsianHestonEngine::AnalyticContinuousGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const &,Size)\n"
    "    AnalyticContinuousGeometricAveragePriceAsianHestonEngine::AnalyticContinuousGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticContinuousGeometricAveragePriceAsianHestonEngine *arg1 = (AnalyticContinuousGeometricAveragePriceAsianHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianHestonEngine > tempshared1 ;
  ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "AnalyticContinuousGeometricAveragePriceAsianHestonEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousGeometricAveragePriceAsianHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticContinuousGeometricAveragePriceAsianHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousGeometricAveragePriceAsianHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDiscreteGeometricAveragePriceAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticDiscreteGeometricAveragePriceAsianEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDiscreteGeometricAveragePriceAsianEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianEngine *)new AnalyticDiscreteGeometricAveragePriceAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDiscreteGeometricAveragePriceAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDiscreteGeometricAveragePriceAsianEngine *arg1 = (AnalyticDiscreteGeometricAveragePriceAsianEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDiscreteGeometricAveragePriceAsianEngine" "', argument " "1"" of type '" "AnalyticDiscreteGeometricAveragePriceAsianEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine > * >(argp1);
      arg1 = const_cast< AnalyticDiscreteGeometricAveragePriceAsianEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianEngine > * >(argp1);
      arg1 = const_cast< AnalyticDiscreteGeometricAveragePriceAsianEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *)new AnalyticDiscreteGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *)new AnalyticDiscreteGeometricAveragePriceAsianHestonEngine((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticDiscreteGeometricAveragePriceAsianHestonEngine::AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const &,Real)\n"
    "    AnalyticDiscreteGeometricAveragePriceAsianHestonEngine::AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *arg1 = (AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine" "', argument " "1"" of type '" "AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > * >(argp1);
      arg1 = const_cast< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticDiscreteGeometricAverageStrikeAsianEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDiscreteGeometricAverageStrikeAsianEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDiscreteGeometricAverageStrikeAsianEngine *)new AnalyticDiscreteGeometricAverageStrikeAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDiscreteGeometricAverageStrikeAsianEngine *arg1 = (AnalyticDiscreteGeometricAverageStrikeAsianEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine" "', argument " "1"" of type '" "AnalyticDiscreteGeometricAverageStrikeAsianEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine > * >(argp1);
      arg1 = const_cast< AnalyticDiscreteGeometricAverageStrikeAsianEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDiscreteGeometricAverageStrikeAsianEngine > * >(argp1);
      arg1 = const_cast< AnalyticDiscreteGeometricAverageStrikeAsianEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDiscreteGeometricAverageStrikeAsianEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRDiscreteArithmeticAPEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"controlVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDiscreteArithmeticAPEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCPRDiscreteArithmeticAPEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRDiscreteArithmeticAPEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRDiscreteArithmeticAPEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCPRDiscreteArithmeticAPEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRDiscreteArithmeticAPEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCPRDiscreteArithmeticAPEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRDiscreteArithmeticAPEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteArithmeticAPEngine< PseudoRandom > *arg1 = (MCDiscreteArithmeticAPEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRDiscreteArithmeticAPEngine" "', argument " "1"" of type '" "MCDiscreteArithmeticAPEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRDiscreteArithmeticAPEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRDiscreteArithmeticAPEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDDiscreteArithmeticAPEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  bool arg4 = (bool) false ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  BigInteger arg8 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  long val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"controlVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCLDDiscreteArithmeticAPEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDDiscreteArithmeticAPEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDDiscreteArithmeticAPEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCLDDiscreteArithmeticAPEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDDiscreteArithmeticAPEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_long(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MCLDDiscreteArithmeticAPEngine" "', argument " "8"" of type '" "BigInteger""'");
    } 
    arg8 = static_cast< BigInteger >(val8);
  }
  {
    try {
      result = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDDiscreteArithmeticAPEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteArithmeticAPEngine< LowDiscrepancy > *arg1 = (MCDiscreteArithmeticAPEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDDiscreteArithmeticAPEngine" "', argument " "1"" of type '" "MCDiscreteArithmeticAPEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDDiscreteArithmeticAPEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDDiscreteArithmeticAPEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRDiscreteArithmeticAPHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  doubleOrNull arg4 = (doubleOrNull) Null< Real >() ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  BigInteger arg6 = (BigInteger) 0 ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  bool arg9 = (bool) false ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"controlVariate",  NULL 
  };
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPRDiscreteArithmeticAPHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRDiscreteArithmeticAPHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRDiscreteArithmeticAPHestonEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<double>();
      else if (PyFloat_Check(obj3))
      arg4 = PyFloat_AsDouble(obj3);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_long(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MCPRDiscreteArithmeticAPHestonEngine" "', argument " "6"" of type '" "BigInteger""'");
    } 
    arg6 = static_cast< BigInteger >(val6);
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRDiscreteArithmeticAPHestonEngine" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRDiscreteArithmeticAPHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *arg1 = (MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRDiscreteArithmeticAPHestonEngine" "', argument " "1"" of type '" "MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRDiscreteArithmeticAPHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRDiscreteArithmeticAPHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDDiscreteArithmeticAPHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  doubleOrNull arg4 = (doubleOrNull) Null< Real >() ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  BigInteger arg6 = (BigInteger) 0 ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  bool arg9 = (bool) false ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"controlVariate",  NULL 
  };
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDDiscreteArithmeticAPHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDDiscreteArithmeticAPHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDDiscreteArithmeticAPHestonEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<double>();
      else if (PyFloat_Check(obj3))
      arg4 = PyFloat_AsDouble(obj3);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_long(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MCLDDiscreteArithmeticAPHestonEngine" "', argument " "6"" of type '" "BigInteger""'");
    } 
    arg6 = static_cast< BigInteger >(val6);
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDDiscreteArithmeticAPHestonEngine" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  {
    try {
      result = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticAPHestonEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDDiscreteArithmeticAPHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *arg1 = (MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDDiscreteArithmeticAPHestonEngine" "', argument " "1"" of type '" "MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticAPHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDDiscreteArithmeticAPHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDDiscreteArithmeticAPHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRDiscreteArithmeticASEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDiscreteArithmeticASEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCPRDiscreteArithmeticASEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRDiscreteArithmeticASEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRDiscreteArithmeticASEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCPRDiscreteArithmeticASEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCPRDiscreteArithmeticASEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCDiscreteArithmeticASEngine< PseudoRandom > *)new_MCDiscreteArithmeticASEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRDiscreteArithmeticASEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteArithmeticASEngine< PseudoRandom > *arg1 = (MCDiscreteArithmeticASEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRDiscreteArithmeticASEngine" "', argument " "1"" of type '" "MCDiscreteArithmeticASEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticASEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticASEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticASEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRDiscreteArithmeticASEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRDiscreteArithmeticASEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDDiscreteArithmeticASEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCLDDiscreteArithmeticASEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDDiscreteArithmeticASEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDDiscreteArithmeticASEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCLDDiscreteArithmeticASEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCLDDiscreteArithmeticASEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *)new_MCDiscreteArithmeticASEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDDiscreteArithmeticASEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteArithmeticASEngine< LowDiscrepancy > *arg1 = (MCDiscreteArithmeticASEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDDiscreteArithmeticASEngine" "', argument " "1"" of type '" "MCDiscreteArithmeticASEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticASEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteArithmeticASEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteArithmeticASEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDDiscreteArithmeticASEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDDiscreteArithmeticASEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRDiscreteGeometricAPEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDiscreteGeometricAPEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCPRDiscreteGeometricAPEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRDiscreteGeometricAPEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRDiscreteGeometricAPEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCPRDiscreteGeometricAPEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCPRDiscreteGeometricAPEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCDiscreteGeometricAPEngine< PseudoRandom > *)new_MCDiscreteGeometricAPEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRDiscreteGeometricAPEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteGeometricAPEngine< PseudoRandom > *arg1 = (MCDiscreteGeometricAPEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRDiscreteGeometricAPEngine" "', argument " "1"" of type '" "MCDiscreteGeometricAPEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRDiscreteGeometricAPEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRDiscreteGeometricAPEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDDiscreteGeometricAPEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCLDDiscreteGeometricAPEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDDiscreteGeometricAPEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDDiscreteGeometricAPEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCLDDiscreteGeometricAPEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCLDDiscreteGeometricAPEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDDiscreteGeometricAPEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteGeometricAPEngine< LowDiscrepancy > *arg1 = (MCDiscreteGeometricAPEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDDiscreteGeometricAPEngine" "', argument " "1"" of type '" "MCDiscreteGeometricAPEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDDiscreteGeometricAPEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDDiscreteGeometricAPEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRDiscreteGeometricAPHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  doubleOrNull arg4 = (doubleOrNull) Null< Real >() ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  BigInteger arg6 = (BigInteger) 0 ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  NULL 
  };
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCPRDiscreteGeometricAPHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRDiscreteGeometricAPHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRDiscreteGeometricAPHestonEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<double>();
      else if (PyFloat_Check(obj3))
      arg4 = PyFloat_AsDouble(obj3);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_long(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MCPRDiscreteGeometricAPHestonEngine" "', argument " "6"" of type '" "BigInteger""'");
    } 
    arg6 = static_cast< BigInteger >(val6);
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *)new_MCDiscreteGeometricAPHestonEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRDiscreteGeometricAPHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteGeometricAPHestonEngine< PseudoRandom > *arg1 = (MCDiscreteGeometricAPHestonEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRDiscreteGeometricAPHestonEngine" "', argument " "1"" of type '" "MCDiscreteGeometricAPHestonEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPHestonEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPHestonEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRDiscreteGeometricAPHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRDiscreteGeometricAPHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDDiscreteGeometricAPHestonEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  doubleOrNull arg4 = (doubleOrNull) Null< Real >() ;
  intOrNull arg5 = (intOrNull) Null< Size >() ;
  BigInteger arg6 = (BigInteger) 0 ;
  intOrNull arg7 = (intOrNull) Null< Size >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  NULL 
  };
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOO:new_MCLDDiscreteGeometricAPHestonEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDDiscreteGeometricAPHestonEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDDiscreteGeometricAPHestonEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<double>();
      else if (PyFloat_Check(obj3))
      arg4 = PyFloat_AsDouble(obj3);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<int>();
      else if (PyInt_Check(obj4))
      arg5 = int(PyInt_AsLong(obj4));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_long(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MCLDDiscreteGeometricAPHestonEngine" "', argument " "6"" of type '" "BigInteger""'");
    } 
    arg6 = static_cast< BigInteger >(val6);
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<int>();
      else if (PyInt_Check(obj6))
      arg7 = int(PyInt_AsLong(obj6));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  {
    try {
      result = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *)new_MCDiscreteGeometricAPHestonEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< HestonProcess > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6,SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDDiscreteGeometricAPHestonEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *arg1 = (MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDDiscreteGeometricAPHestonEngine" "', argument " "1"" of type '" "MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCDiscreteGeometricAPHestonEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDDiscreteGeometricAPHestonEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDDiscreteGeometricAPHestonEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ContinuousArithmeticAsianLevyEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  ContinuousArithmeticAsianLevyEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ContinuousArithmeticAsianLevyEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContinuousArithmeticAsianLevyEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContinuousArithmeticAsianLevyEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContinuousArithmeticAsianLevyEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ContinuousArithmeticAsianLevyEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContinuousArithmeticAsianLevyEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (ContinuousArithmeticAsianLevyEngine *)new ContinuousArithmeticAsianLevyEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(Handle< Quote > const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine > *smartresult = result ? new ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ContinuousArithmeticAsianLevyEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ContinuousArithmeticAsianLevyEngine *arg1 = (ContinuousArithmeticAsianLevyEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > tempshared1 ;
  ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContinuousArithmeticAsianLevyEngine" "', argument " "1"" of type '" "ContinuousArithmeticAsianLevyEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine > * >(argp1);
      arg1 = const_cast< ContinuousArithmeticAsianLevyEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ContinuousArithmeticAsianLevyEngine > * >(argp1);
      arg1 = const_cast< ContinuousArithmeticAsianLevyEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContinuousArithmeticAsianLevyEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ContinuousArithmeticAsianLevyEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdBlackScholesAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  FdBlackScholesAsianEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdBlackScholesAsianEngine", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesAsianEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesAsianEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesAsianEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesAsianEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesAsianEngine *)new FdBlackScholesAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesAsianEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesAsianEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesAsianEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdBlackScholesAsianEngine *arg1 = (FdBlackScholesAsianEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdBlackScholesAsianEngine > tempshared1 ;
  ext::shared_ptr< FdBlackScholesAsianEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesAsianEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdBlackScholesAsianEngine" "', argument " "1"" of type '" "FdBlackScholesAsianEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdBlackScholesAsianEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdBlackScholesAsianEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesAsianEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdBlackScholesAsianEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesAsianEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdBlackScholesAsianEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesAsianEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdBlackScholesAsianEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TurnbullWakemanAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  TurnbullWakemanAsianEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TurnbullWakemanAsianEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (TurnbullWakemanAsianEngine *)new TurnbullWakemanAsianEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TurnbullWakemanAsianEngine > *smartresult = result ? new ext::shared_ptr<  TurnbullWakemanAsianEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TurnbullWakemanAsianEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TurnbullWakemanAsianEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TurnbullWakemanAsianEngine *arg1 = (TurnbullWakemanAsianEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TurnbullWakemanAsianEngine > tempshared1 ;
  ext::shared_ptr< TurnbullWakemanAsianEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TurnbullWakemanAsianEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TurnbullWakemanAsianEngine" "', argument " "1"" of type '" "TurnbullWakemanAsianEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TurnbullWakemanAsianEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TurnbullWakemanAsianEngine > * >(argp1);
      arg1 = const_cast< TurnbullWakemanAsianEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TurnbullWakemanAsianEngine > * >(argp1);
      arg1 = const_cast< TurnbullWakemanAsianEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TurnbullWakemanAsianEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TurnbullWakemanAsianEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TurnbullWakemanAsianEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Barrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Barrier *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Barrier", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Barrier *)new Barrier();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Barrier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Barrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Barrier *arg1 = (Barrier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Barrier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Barrier" "', argument " "1"" of type '" "Barrier *""'"); 
  }
  arg1 = reinterpret_cast< Barrier * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Barrier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Barrier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Barrier_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< Exercise > tempshared5 ;
  PyObject *swig_obj[5] ;
  BarrierOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BarrierOption", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BarrierOption" "', argument " "1"" of type '" "Barrier::Type""'");
  } 
  arg1 = static_cast< Barrier::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BarrierOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BarrierOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BarrierOption" "', argument " "4"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_BarrierOption" "', argument " "5"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (BarrierOption *)new BarrierOption(arg1,arg2,arg3,(ext::shared_ptr< StrikedTypePayoff > const &)*arg4,(ext::shared_ptr< Exercise > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BarrierOption > *smartresult = result ? new ext::shared_ptr<  BarrierOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BarrierOption_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BarrierOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BarrierOption_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Volatility result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BarrierOption_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BarrierOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BarrierOption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BarrierOption_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BarrierOption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BarrierOption_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BarrierOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  Real arg2 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  DividendSchedule *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BarrierOption_impliedVolatility" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BarrierOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BarrierOption_impliedVolatility" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BarrierOption_impliedVolatility" "', argument " "4"" of type '" "DividendSchedule const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,(DividendSchedule const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BarrierOption_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BarrierOption_impliedVolatility", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BarrierOption_impliedVolatility__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BarrierOption_impliedVolatility__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BarrierOption_impliedVolatility__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BarrierOption_impliedVolatility__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BarrierOption_impliedVolatility__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BarrierOption_impliedVolatility__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BarrierOption_impliedVolatility__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_BarrierOption_impliedVolatility__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_BarrierOption_impliedVolatility__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BarrierOption_impliedVolatility__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BarrierOption_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Volatility,Volatility)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Volatility)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real,Size,Volatility,Volatility)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real,Size,Volatility)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real,Size)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &,Real)\n"
    "    BarrierOption::impliedVolatility(Real,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BarrierOption *arg1 = (BarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BarrierOption > tempshared1 ;
  ext::shared_ptr< BarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BarrierOption" "', argument " "1"" of type '" "BarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BarrierOption > * >(argp1);
      arg1 = const_cast< BarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BarrierOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BarrierOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BarrierOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< Exercise > tempshared5 ;
  PyObject *swig_obj[5] ;
  QuantoBarrierOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoBarrierOption", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuantoBarrierOption" "', argument " "1"" of type '" "Barrier::Type""'");
  } 
  arg1 = static_cast< Barrier::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QuantoBarrierOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QuantoBarrierOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_QuantoBarrierOption" "', argument " "4"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_QuantoBarrierOption" "', argument " "5"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (QuantoBarrierOption *)new QuantoBarrierOption(arg1,arg2,arg3,(ext::shared_ptr< StrikedTypePayoff > const &)*arg4,(ext::shared_ptr< Exercise > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoBarrierOption > *smartresult = result ? new ext::shared_ptr<  QuantoBarrierOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoBarrierOption *arg1 = (QuantoBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoBarrierOption > tempshared1 ;
  ext::shared_ptr< QuantoBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoBarrierOption" "', argument " "1"" of type '" "QuantoBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoBarrierOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoBarrierOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PartialBarrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PartialBarrier *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PartialBarrier", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (PartialBarrier *)new PartialBarrier();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PartialBarrier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PartialBarrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PartialBarrier *arg1 = (PartialBarrier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PartialBarrier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartialBarrier" "', argument " "1"" of type '" "PartialBarrier *""'"); 
  }
  arg1 = reinterpret_cast< PartialBarrier * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartialBarrier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PartialBarrier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PartialBarrier_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PartialTimeBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PartialBarrier::Type arg1 ;
  PartialBarrier::Range arg2 ;
  Real arg3 ;
  Real arg4 ;
  Date arg5 ;
  ext::shared_ptr< StrikedTypePayoff > *arg6 = 0 ;
  ext::shared_ptr< Exercise > *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< Exercise > tempshared7 ;
  PyObject *swig_obj[7] ;
  PartialTimeBarrierOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PartialTimeBarrierOption", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PartialTimeBarrierOption" "', argument " "1"" of type '" "PartialBarrier::Type""'");
  } 
  arg1 = static_cast< PartialBarrier::Type >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PartialTimeBarrierOption" "', argument " "2"" of type '" "PartialBarrier::Range""'");
  } 
  arg2 = static_cast< PartialBarrier::Range >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PartialTimeBarrierOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PartialTimeBarrierOption" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PartialTimeBarrierOption" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartialTimeBarrierOption" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PartialTimeBarrierOption" "', argument " "6"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PartialTimeBarrierOption" "', argument " "7"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (PartialTimeBarrierOption *)new PartialTimeBarrierOption(arg1,arg2,arg3,arg4,arg5,(ext::shared_ptr< StrikedTypePayoff > const &)*arg6,(ext::shared_ptr< Exercise > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PartialTimeBarrierOption > *smartresult = result ? new ext::shared_ptr<  PartialTimeBarrierOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PartialTimeBarrierOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PartialTimeBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PartialTimeBarrierOption *arg1 = (PartialTimeBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PartialTimeBarrierOption > tempshared1 ;
  ext::shared_ptr< PartialTimeBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PartialTimeBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartialTimeBarrierOption" "', argument " "1"" of type '" "PartialTimeBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PartialTimeBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PartialTimeBarrierOption > * >(argp1);
      arg1 = const_cast< PartialTimeBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PartialTimeBarrierOption > * >(argp1);
      arg1 = const_cast< PartialTimeBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartialTimeBarrierOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PartialTimeBarrierOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PartialTimeBarrierOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticPartialTimeBarrierOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticPartialTimeBarrierOptionEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPartialTimeBarrierOptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticPartialTimeBarrierOptionEngine *)new AnalyticPartialTimeBarrierOptionEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPartialTimeBarrierOptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticPartialTimeBarrierOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticPartialTimeBarrierOptionEngine *arg1 = (AnalyticPartialTimeBarrierOptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticPartialTimeBarrierOptionEngine > tempshared1 ;
  ext::shared_ptr< AnalyticPartialTimeBarrierOptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticPartialTimeBarrierOptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticPartialTimeBarrierOptionEngine" "', argument " "1"" of type '" "AnalyticPartialTimeBarrierOptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine > * >(argp1);
      arg1 = const_cast< AnalyticPartialTimeBarrierOptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticPartialTimeBarrierOptionEngine > * >(argp1);
      arg1 = const_cast< AnalyticPartialTimeBarrierOptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticPartialTimeBarrierOptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticPartialTimeBarrierOptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticPartialTimeBarrierOptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DividendBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Barrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  ext::shared_ptr< StrikedTypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< Exercise > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  PyObject *swig_obj[7] ;
  DividendBarrierOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DividendBarrierOption", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DividendBarrierOption" "', argument " "1"" of type '" "Barrier::Type""'");
  } 
  arg1 = static_cast< Barrier::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DividendBarrierOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DividendBarrierOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DividendBarrierOption" "', argument " "4"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DividendBarrierOption" "', argument " "5"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5) : &tempshared5;
    }
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_DividendBarrierOption" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DividendBarrierOption" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DividendBarrierOption" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DividendBarrierOption" "', argument " "7"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      result = (DividendBarrierOption *)new DividendBarrierOption(arg1,arg2,arg3,(ext::shared_ptr< StrikedTypePayoff > const &)*arg4,(ext::shared_ptr< Exercise > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(std::vector< Real,std::allocator< Real > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DividendBarrierOption > *smartresult = result ? new ext::shared_ptr<  DividendBarrierOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DividendBarrierOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DividendBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DividendBarrierOption *arg1 = (DividendBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DividendBarrierOption > tempshared1 ;
  ext::shared_ptr< DividendBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DividendBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DividendBarrierOption" "', argument " "1"" of type '" "DividendBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DividendBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DividendBarrierOption > * >(argp1);
      arg1 = const_cast< DividendBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DividendBarrierOption > * >(argp1);
      arg1 = const_cast< DividendBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DividendBarrierOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DividendBarrierOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DividendBarrierOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticBarrierEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticBarrierEngine *)new AnalyticBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticBarrierEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticBarrierEngine *arg1 = (AnalyticBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticBarrierEngine > tempshared1 ;
  ext::shared_ptr< AnalyticBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticBarrierEngine" "', argument " "1"" of type '" "AnalyticBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticBarrierEngine > * >(argp1);
      arg1 = const_cast< AnalyticBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticBarrierEngine > * >(argp1);
      arg1 = const_cast< AnalyticBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRBarrierEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  bool arg9 = (bool) false ;
  BigInteger arg10 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"isBiased",  (char *)"seed",  NULL 
  };
  MCBarrierEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOO:new_MCPRBarrierEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRBarrierEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPRBarrierEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRBarrierEngine" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_long(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_MCPRBarrierEngine" "', argument " "10"" of type '" "BigInteger""'");
    } 
    arg10 = static_cast< BigInteger >(val10);
  }
  {
    try {
      result = (MCBarrierEngine< PseudoRandom > *)new_MCBarrierEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCBarrierEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCBarrierEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCBarrierEngine< PseudoRandom > *arg1 = (MCBarrierEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCBarrierEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCBarrierEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRBarrierEngine" "', argument " "1"" of type '" "MCBarrierEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCBarrierEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCBarrierEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCBarrierEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCBarrierEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCBarrierEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDBarrierEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  bool arg9 = (bool) false ;
  BigInteger arg10 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"isBiased",  (char *)"seed",  NULL 
  };
  MCBarrierEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOO:new_MCLDBarrierEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDBarrierEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDBarrierEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDBarrierEngine" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_long(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_MCLDBarrierEngine" "', argument " "10"" of type '" "BigInteger""'");
    } 
    arg10 = static_cast< BigInteger >(val10);
  }
  {
    try {
      result = (MCBarrierEngine< LowDiscrepancy > *)new_MCBarrierEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCBarrierEngine< LowDiscrepancy > *arg1 = (MCBarrierEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDBarrierEngine" "', argument " "1"" of type '" "MCBarrierEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCBarrierEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCBarrierEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCBarrierEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Handle< YieldTermStructure > arg2 ;
  Handle< BlackVolTermStructure > arg3 ;
  Handle< Quote > arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  QuantoBarrierEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoBarrierEngine", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantoBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuantoBarrierEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoBarrierEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_QuantoBarrierEngine" "', argument " "3"" of type '" "Handle< BlackVolTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoBarrierEngine" "', argument " "3"" of type '" "Handle< BlackVolTermStructure >""'");
    } else {
      Handle< BlackVolTermStructure > * temp = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_QuantoBarrierEngine" "', argument " "4"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantoBarrierEngine" "', argument " "4"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (QuantoBarrierEngine *)new QuantoBarrierEngine(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoBarrierEngine > *smartresult = result ? new ext::shared_ptr<  QuantoBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoBarrierEngine *arg1 = (QuantoBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoBarrierEngine > tempshared1 ;
  ext::shared_ptr< QuantoBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoBarrierEngine" "', argument " "1"" of type '" "QuantoBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoBarrierEngine > * >(argp1);
      arg1 = const_cast< QuantoBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoBarrierEngine > * >(argp1);
      arg1 = const_cast< QuantoBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdBlackScholesBarrierEngine *)new FdBlackScholesBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesBarrierEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdBlackScholesBarrierEngine__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdBlackScholesBarrierEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdBlackScholesBarrierEngine__SWIG_13(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesBarrierEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesBarrierEngine__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesBarrierEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesBarrierEngine__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdBlackScholesBarrierEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBlackScholesBarrierEngine__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdBlackScholesBarrierEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdBlackScholesBarrierEngine__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesBarrierEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesBarrierEngine__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdBlackScholesBarrierEngine__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdBlackScholesBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size)\n"
    "    FdBlackScholesBarrierEngine::FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdBlackScholesBarrierEngine *arg1 = (FdBlackScholesBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdBlackScholesBarrierEngine > tempshared1 ;
  ext::shared_ptr< FdBlackScholesBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdBlackScholesBarrierEngine" "', argument " "1"" of type '" "FdBlackScholesBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdBlackScholesBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdBlackScholesBarrierEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdBlackScholesBarrierEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdBlackScholesBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdBlackScholesBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  FdmSchemeDesc *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,(FdmSchemeDesc const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdBlackScholesRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdBlackScholesRebateEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdBlackScholesRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdBlackScholesRebateEngine *)new FdBlackScholesRebateEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdBlackScholesRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdBlackScholesRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdBlackScholesRebateEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdBlackScholesRebateEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdBlackScholesRebateEngine__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdBlackScholesRebateEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdBlackScholesRebateEngine__SWIG_13(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesRebateEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdBlackScholesRebateEngine__SWIG_12(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesRebateEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdBlackScholesRebateEngine__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdBlackScholesRebateEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdBlackScholesRebateEngine__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdBlackScholesRebateEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdBlackScholesRebateEngine__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesRebateEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FdBlackScholesRebateEngine__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdBlackScholesRebateEngine__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdBlackScholesRebateEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,Size)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size,Size)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule,Size)\n"
    "    FdBlackScholesRebateEngine::FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdBlackScholesRebateEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdBlackScholesRebateEngine *arg1 = (FdBlackScholesRebateEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdBlackScholesRebateEngine > tempshared1 ;
  ext::shared_ptr< FdBlackScholesRebateEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdBlackScholesRebateEngine" "', argument " "1"" of type '" "FdBlackScholesRebateEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdBlackScholesRebateEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdBlackScholesRebateEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesRebateEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdBlackScholesRebateEngine > * >(argp1);
      arg1 = const_cast< FdBlackScholesRebateEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdBlackScholesRebateEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdBlackScholesRebateEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdBlackScholesRebateEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  double val8 ;
  int ecode8 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonBarrierEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonBarrierEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonBarrierEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonBarrierEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonBarrierEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonBarrierEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdHestonBarrierEngine *)new FdHestonBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonBarrierEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdHestonBarrierEngine__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdHestonBarrierEngine__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdHestonBarrierEngine__SWIG_15(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonBarrierEngine__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonBarrierEngine__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonBarrierEngine__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonBarrierEngine__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonBarrierEngine__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonBarrierEngine__SWIG_12(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdHestonBarrierEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonBarrierEngine__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonBarrierEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonBarrierEngine__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdHestonBarrierEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FdHestonBarrierEngine__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdHestonBarrierEngine__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdHestonBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size)\n"
    "    FdHestonBarrierEngine::FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdHestonBarrierEngine *arg1 = (FdHestonBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdHestonBarrierEngine > tempshared1 ;
  ext::shared_ptr< FdHestonBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdHestonBarrierEngine" "', argument " "1"" of type '" "FdHestonBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdHestonBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdHestonBarrierEngine > * >(argp1);
      arg1 = const_cast< FdHestonBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdHestonBarrierEngine > * >(argp1);
      arg1 = const_cast< FdHestonBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdHestonBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdHestonBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdHestonBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  double val8 ;
  int ecode8 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonRebateEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonRebateEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FdHestonRebateEngine" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared8 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdHestonRebateEngine" "', argument " "8"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7,(ext::shared_ptr< LocalVolTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 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 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonRebateEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdHestonRebateEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonRebateEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonRebateEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonRebateEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  DividendSchedule arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonRebateEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonRebateEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FdHestonRebateEngine" "', argument " "2"" of type '" "DividendSchedule""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (FdHestonRebateEngine *)new FdHestonRebateEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonRebateEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonRebateEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonRebateEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonRebateEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdHestonRebateEngine__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdHestonRebateEngine__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdHestonRebateEngine__SWIG_15(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonRebateEngine__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonRebateEngine__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonRebateEngine__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonRebateEngine__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonRebateEngine__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonRebateEngine__SWIG_12(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdHestonRebateEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdHestonRebateEngine__SWIG_11(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonRebateEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonRebateEngine__SWIG_10(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdHestonRebateEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FdHestonRebateEngine__SWIG_9(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FdHestonRebateEngine__SWIG_8(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdHestonRebateEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule,Size)\n"
    "    FdHestonRebateEngine::FdHestonRebateEngine(ext::shared_ptr< HestonModel > const &,DividendSchedule)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonRebateEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdHestonRebateEngine *arg1 = (FdHestonRebateEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdHestonRebateEngine > tempshared1 ;
  ext::shared_ptr< FdHestonRebateEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdHestonRebateEngine" "', argument " "1"" of type '" "FdHestonRebateEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdHestonRebateEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdHestonRebateEngine > * >(argp1);
      arg1 = const_cast< FdHestonRebateEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdHestonRebateEngine > * >(argp1);
      arg1 = const_cast< FdHestonRebateEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdHestonRebateEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdHestonRebateEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdHestonRebateEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticBinaryBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticBinaryBarrierEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticBinaryBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticBinaryBarrierEngine *)new AnalyticBinaryBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticBinaryBarrierEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticBinaryBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticBinaryBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticBinaryBarrierEngine *arg1 = (AnalyticBinaryBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticBinaryBarrierEngine > tempshared1 ;
  ext::shared_ptr< AnalyticBinaryBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticBinaryBarrierEngine" "', argument " "1"" of type '" "AnalyticBinaryBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticBinaryBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticBinaryBarrierEngine > * >(argp1);
      arg1 = const_cast< AnalyticBinaryBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticBinaryBarrierEngine > * >(argp1);
      arg1 = const_cast< AnalyticBinaryBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticBinaryBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticBinaryBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialCRRBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialCRRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialCRRBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialCRRBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialCRRBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialCRRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialCRRBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialCRRBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialCRRBarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialCRRBarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialCRRBarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialCRRBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialCRRBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialCRRBarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialCRRBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialCRRBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJRBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJRBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialJRBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJRBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJRBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJRBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialJRBarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialJRBarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialJRBarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialJRBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJRBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJRBarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<JarrowRudd,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJRBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJRBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialEQPBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialEQPBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialEQPBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialEQPBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialEQPBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialEQPBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialEQPBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialEQPBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialEQPBarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialEQPBarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialEQPBarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialEQPBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialEQPBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialEQPBarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialEQPBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialEQPBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTrigeorgisBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTrigeorgisBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialTrigeorgisBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTrigeorgisBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTrigeorgisBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialTrigeorgisBarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialTrigeorgisBarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialTrigeorgisBarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialTrigeorgisBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTrigeorgisBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTrigeorgisBarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Trigeorgis,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTrigeorgisBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTrigeorgisBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTianBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTianBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTianBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialTianBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTianBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTianBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTianBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTianBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialTianBarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialTianBarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialTianBarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialTianBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTianBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTianBarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Tian,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTianBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTianBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialLRBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialLRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialLRBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialLRBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialLRBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialLRBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialLRBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialLRBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialLRBarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialLRBarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialLRBarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialLRBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialLRBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialLRBarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<LeisenReimer,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialLRBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialLRBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJ4BarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJ4BarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJ4BarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BinomialJ4BarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJ4BarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJ4BarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJ4BarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *)new BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJ4BarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialJ4BarrierEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BinomialJ4BarrierEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BinomialJ4BarrierEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialJ4BarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption >::BinomialBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJ4BarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *arg1 = (BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJ4BarrierEngine" "', argument " "1"" of type '" "BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialBarrierEngine<Joshi4,DiscretizedDermanKaniBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJ4BarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJ4BarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VannaVolgaBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *arg2 = 0 ;
  Handle< DeltaVolQuote > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  VannaVolgaBarrierEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (VannaVolgaBarrierEngine *)new VannaVolgaBarrierEngine((Handle< DeltaVolQuote > const &)*arg1,(Handle< DeltaVolQuote > const &)*arg2,(Handle< DeltaVolQuote > const &)*arg3,(Handle< Quote > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaBarrierEngine > *smartresult = result ? new ext::shared_ptr<  VannaVolgaBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *arg2 = 0 ;
  Handle< DeltaVolQuote > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  VannaVolgaBarrierEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (VannaVolgaBarrierEngine *)new VannaVolgaBarrierEngine((Handle< DeltaVolQuote > const &)*arg1,(Handle< DeltaVolQuote > const &)*arg2,(Handle< DeltaVolQuote > const &)*arg3,(Handle< Quote > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaBarrierEngine > *smartresult = result ? new ext::shared_ptr<  VannaVolgaBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaBarrierEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > *arg1 = 0 ;
  Handle< DeltaVolQuote > *arg2 = 0 ;
  Handle< DeltaVolQuote > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  VannaVolgaBarrierEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (VannaVolgaBarrierEngine *)new VannaVolgaBarrierEngine((Handle< DeltaVolQuote > const &)*arg1,(Handle< DeltaVolQuote > const &)*arg2,(Handle< DeltaVolQuote > const &)*arg3,(Handle< Quote > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaBarrierEngine > *smartresult = result ? new ext::shared_ptr<  VannaVolgaBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VannaVolgaBarrierEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_VannaVolgaBarrierEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_VannaVolgaBarrierEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_VannaVolgaBarrierEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VannaVolgaBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VannaVolgaBarrierEngine::VannaVolgaBarrierEngine(Handle< DeltaVolQuote > const &,Handle< DeltaVolQuote > const &,Handle< DeltaVolQuote > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,bool const,Real const)\n"
    "    VannaVolgaBarrierEngine::VannaVolgaBarrierEngine(Handle< DeltaVolQuote > const &,Handle< DeltaVolQuote > const &,Handle< DeltaVolQuote > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,bool const)\n"
    "    VannaVolgaBarrierEngine::VannaVolgaBarrierEngine(Handle< DeltaVolQuote > const &,Handle< DeltaVolQuote > const &,Handle< DeltaVolQuote > const &,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VannaVolgaBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VannaVolgaBarrierEngine *arg1 = (VannaVolgaBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VannaVolgaBarrierEngine > tempshared1 ;
  ext::shared_ptr< VannaVolgaBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VannaVolgaBarrierEngine" "', argument " "1"" of type '" "VannaVolgaBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VannaVolgaBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VannaVolgaBarrierEngine > * >(argp1);
      arg1 = const_cast< VannaVolgaBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VannaVolgaBarrierEngine > * >(argp1);
      arg1 = const_cast< VannaVolgaBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VannaVolgaBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VannaVolgaBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VannaVolgaBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DoubleBarrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DoubleBarrier *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DoubleBarrier", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (DoubleBarrier *)new DoubleBarrier();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DoubleBarrier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleBarrier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DoubleBarrier *arg1 = (DoubleBarrier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DoubleBarrier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleBarrier" "', argument " "1"" of type '" "DoubleBarrier *""'"); 
  }
  arg1 = reinterpret_cast< DoubleBarrier * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoubleBarrier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DoubleBarrier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DoubleBarrier_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DoubleBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DoubleBarrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< StrikedTypePayoff > *arg5 = 0 ;
  ext::shared_ptr< Exercise > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< Exercise > tempshared6 ;
  PyObject *swig_obj[6] ;
  DoubleBarrierOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DoubleBarrierOption", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleBarrierOption" "', argument " "1"" of type '" "DoubleBarrier::Type""'");
  } 
  arg1 = static_cast< DoubleBarrier::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleBarrierOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleBarrierOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DoubleBarrierOption" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DoubleBarrierOption" "', argument " "5"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5) : &tempshared5;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_DoubleBarrierOption" "', argument " "6"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (DoubleBarrierOption *)new DoubleBarrierOption(arg1,arg2,arg3,arg4,(ext::shared_ptr< StrikedTypePayoff > const &)*arg5,(ext::shared_ptr< Exercise > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DoubleBarrierOption > *smartresult = result ? new ext::shared_ptr<  DoubleBarrierOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DoubleBarrierOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DoubleBarrierOption *arg1 = (DoubleBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DoubleBarrierOption > tempshared1 ;
  ext::shared_ptr< DoubleBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DoubleBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleBarrierOption" "', argument " "1"" of type '" "DoubleBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DoubleBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DoubleBarrierOption > * >(argp1);
      arg1 = const_cast< DoubleBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DoubleBarrierOption > * >(argp1);
      arg1 = const_cast< DoubleBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoubleBarrierOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DoubleBarrierOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DoubleBarrierOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_QuantoDoubleBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DoubleBarrier::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  ext::shared_ptr< StrikedTypePayoff > *arg5 = 0 ;
  ext::shared_ptr< Exercise > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< Exercise > tempshared6 ;
  PyObject *swig_obj[6] ;
  QuantoDoubleBarrierOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_QuantoDoubleBarrierOption", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuantoDoubleBarrierOption" "', argument " "1"" of type '" "DoubleBarrier::Type""'");
  } 
  arg1 = static_cast< DoubleBarrier::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QuantoDoubleBarrierOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_QuantoDoubleBarrierOption" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_QuantoDoubleBarrierOption" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_QuantoDoubleBarrierOption" "', argument " "5"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp5) : &tempshared5;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_QuantoDoubleBarrierOption" "', argument " "6"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (QuantoDoubleBarrierOption *)new QuantoDoubleBarrierOption(arg1,arg2,arg3,arg4,(ext::shared_ptr< StrikedTypePayoff > const &)*arg5,(ext::shared_ptr< Exercise > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  QuantoDoubleBarrierOption > *smartresult = result ? new ext::shared_ptr<  QuantoDoubleBarrierOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuantoDoubleBarrierOption_qvega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > tempshared1 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantoDoubleBarrierOption_qvega" "', argument " "1"" of type '" "QuantoDoubleBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->qvega();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuantoDoubleBarrierOption_qrho(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > tempshared1 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantoDoubleBarrierOption_qrho" "', argument " "1"" of type '" "QuantoDoubleBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->qrho();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_QuantoDoubleBarrierOption_qlambda(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > tempshared1 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantoDoubleBarrierOption_qlambda" "', argument " "1"" of type '" "QuantoDoubleBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->qlambda();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_QuantoDoubleBarrierOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  QuantoDoubleBarrierOption *arg1 = (QuantoDoubleBarrierOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > tempshared1 ;
  ext::shared_ptr< QuantoDoubleBarrierOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantoDoubleBarrierOption" "', argument " "1"" of type '" "QuantoDoubleBarrierOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  QuantoDoubleBarrierOption > * >(argp1);
      arg1 = const_cast< QuantoDoubleBarrierOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuantoDoubleBarrierOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_QuantoDoubleBarrierOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *QuantoDoubleBarrierOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDoubleBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  AnalyticDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AnalyticDoubleBarrierEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (AnalyticDoubleBarrierEngine *)new AnalyticDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticDoubleBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  AnalyticDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDoubleBarrierEngine *)new AnalyticDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticDoubleBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticDoubleBarrierEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticDoubleBarrierEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnalyticDoubleBarrierEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticDoubleBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticDoubleBarrierEngine::AnalyticDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,int)\n"
    "    AnalyticDoubleBarrierEngine::AnalyticDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDoubleBarrierEngine *arg1 = (AnalyticDoubleBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDoubleBarrierEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDoubleBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDoubleBarrierEngine" "', argument " "1"" of type '" "AnalyticDoubleBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDoubleBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< AnalyticDoubleBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< AnalyticDoubleBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  double val8 ;
  int ecode8 = 0 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  int res7 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared7 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "7"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6,(ext::shared_ptr< LocalVolTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  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 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModel > tempshared1 ;
  FdHestonDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdHestonDoubleBarrierEngine *)new FdHestonDoubleBarrierEngine((ext::shared_ptr< HestonModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHestonDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  FdHestonDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHestonDoubleBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHestonDoubleBarrierEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FdHestonDoubleBarrierEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdHestonDoubleBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size,Size)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size,Size)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size,Size)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &,Size)\n"
    "    FdHestonDoubleBarrierEngine::FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHestonDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdHestonDoubleBarrierEngine *arg1 = (FdHestonDoubleBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdHestonDoubleBarrierEngine > tempshared1 ;
  ext::shared_ptr< FdHestonDoubleBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdHestonDoubleBarrierEngine" "', argument " "1"" of type '" "FdHestonDoubleBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdHestonDoubleBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdHestonDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< FdHestonDoubleBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdHestonDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< FdHestonDoubleBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdHestonDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdHestonDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SuoWangDoubleBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  SuoWangDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SuoWangDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SuoWangDoubleBarrierEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (SuoWangDoubleBarrierEngine *)new SuoWangDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SuoWangDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  SuoWangDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuoWangDoubleBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  SuoWangDoubleBarrierEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SuoWangDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (SuoWangDoubleBarrierEngine *)new SuoWangDoubleBarrierEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SuoWangDoubleBarrierEngine > *smartresult = result ? new ext::shared_ptr<  SuoWangDoubleBarrierEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuoWangDoubleBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SuoWangDoubleBarrierEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SuoWangDoubleBarrierEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SuoWangDoubleBarrierEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SuoWangDoubleBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SuoWangDoubleBarrierEngine::SuoWangDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,int)\n"
    "    SuoWangDoubleBarrierEngine::SuoWangDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SuoWangDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SuoWangDoubleBarrierEngine *arg1 = (SuoWangDoubleBarrierEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SuoWangDoubleBarrierEngine > tempshared1 ;
  ext::shared_ptr< SuoWangDoubleBarrierEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SuoWangDoubleBarrierEngine" "', argument " "1"" of type '" "SuoWangDoubleBarrierEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SuoWangDoubleBarrierEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SuoWangDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< SuoWangDoubleBarrierEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SuoWangDoubleBarrierEngine > * >(argp1);
      arg1 = const_cast< SuoWangDoubleBarrierEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SuoWangDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SuoWangDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real arg8 ;
  int arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaIKDoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaIKDoubleBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VannaVolgaIKDoubleBarrierEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_VannaVolgaIKDoubleBarrierEngine__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VannaVolgaIKDoubleBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const,Real const,int)\n"
    "    VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const,Real const)\n"
    "    VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const)\n"
    "    VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VannaVolgaIKDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *arg1 = (VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > tempshared1 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VannaVolgaIKDoubleBarrierEngine" "', argument " "1"" of type '" "VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > * >(argp1);
      arg1 = const_cast< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<AnalyticDoubleBarrierEngine> > * >(argp1);
      arg1 = const_cast< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VannaVolgaIKDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VannaVolgaIKDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real arg8 ;
  int arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DeltaVolQuote > arg1 ;
  Handle< DeltaVolQuote > arg2 ;
  Handle< DeltaVolQuote > arg3 ;
  Handle< Quote > arg4 ;
  Handle< YieldTermStructure > arg5 ;
  Handle< YieldTermStructure > arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "2"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_DeltaVolQuote_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "3"" of type '" "Handle< DeltaVolQuote > const""'");
    } else {
      Handle< DeltaVolQuote > * temp = reinterpret_cast< Handle< DeltaVolQuote > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "4"" of type '" "Handle< Quote > const""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "5"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VannaVolgaWODoubleBarrierEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *)new VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > *smartresult = result ? new ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VannaVolgaWODoubleBarrierEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VannaVolgaWODoubleBarrierEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_DeltaVolQuote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_VannaVolgaWODoubleBarrierEngine__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VannaVolgaWODoubleBarrierEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const,Real const,int)\n"
    "    VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const,Real const)\n"
    "    VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const,bool const)\n"
    "    VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine >::VannaVolgaDoubleBarrierEngine(Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< DeltaVolQuote > const,Handle< Quote > const,Handle< YieldTermStructure > const,Handle< YieldTermStructure > const)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VannaVolgaWODoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *arg1 = (VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > > tempshared1 ;
  ext::shared_ptr< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VannaVolgaWODoubleBarrierEngine" "', argument " "1"" of type '" "VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > * >(argp1);
      arg1 = const_cast< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VannaVolgaDoubleBarrierEngine<SuoWangDoubleBarrierEngine> > * >(argp1);
      arg1 = const_cast< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VannaVolgaWODoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VannaVolgaWODoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticDoubleBarrierBinaryEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticDoubleBarrierBinaryEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticDoubleBarrierBinaryEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticDoubleBarrierBinaryEngine *)new AnalyticDoubleBarrierBinaryEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticDoubleBarrierBinaryEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticDoubleBarrierBinaryEngine *arg1 = (AnalyticDoubleBarrierBinaryEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > tempshared1 ;
  ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticDoubleBarrierBinaryEngine" "', argument " "1"" of type '" "AnalyticDoubleBarrierBinaryEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine > * >(argp1);
      arg1 = const_cast< AnalyticDoubleBarrierBinaryEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticDoubleBarrierBinaryEngine > * >(argp1);
      arg1 = const_cast< AnalyticDoubleBarrierBinaryEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticDoubleBarrierBinaryEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticDoubleBarrierBinaryEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialCRRDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialCRRDoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialCRRDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialCRRDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialCRRDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialCRRDoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialCRRDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialCRRDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJRDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialJRDoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJRDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJRDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJRDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJRDoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJRDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJRDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialEQPDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialEQPDoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialEQPDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialEQPDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialEQPDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialEQPDoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialEQPDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialEQPDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialTrigeorgisDoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTrigeorgisDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTrigeorgisDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTrigeorgisDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTrigeorgisDoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTrigeorgisDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTrigeorgisDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTianDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialTianDoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTianDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTianDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTianDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTianDoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Tian,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTianDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTianDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialLRDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialLRDoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialLRDoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialLRDoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialLRDoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialLRDoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialLRDoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialLRDoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJ4DoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialJ4DoubleBarrierEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJ4DoubleBarrierEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJ4DoubleBarrierEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *)new BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption >((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> > *smartresult = result ? new ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJ4DoubleBarrierEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *arg1 = (BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > tempshared1 ;
  ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJ4DoubleBarrierEngine" "', argument " "1"" of type '" "BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialDoubleBarrierEngine<Joshi4,DiscretizedDermanKaniDoubleBarrierOption> > * >(argp1);
      arg1 = const_cast< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJ4DoubleBarrierEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJ4DoubleBarrierEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PlainVanillaPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PlainVanillaPayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PlainVanillaPayoff", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PlainVanillaPayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PlainVanillaPayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (PlainVanillaPayoff *)new PlainVanillaPayoff(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PlainVanillaPayoff > *smartresult = result ? new ext::shared_ptr<  PlainVanillaPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PlainVanillaPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PlainVanillaPayoff *arg1 = (PlainVanillaPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  ext::shared_ptr< PlainVanillaPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PlainVanillaPayoff" "', argument " "1"" of type '" "PlainVanillaPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PlainVanillaPayoff > * >(argp1);
      arg1 = const_cast< PlainVanillaPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PlainVanillaPayoff > * >(argp1);
      arg1 = const_cast< PlainVanillaPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PlainVanillaPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PlainVanillaPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_plain_vanilla_payoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< PlainVanillaPayoff > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_plain_vanilla_payoff" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_plain_vanilla_payoff((ext::shared_ptr< Payoff > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PlainVanillaPayoff > *smartresult = result ? new ext::shared_ptr<  PlainVanillaPayoff >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PercentageStrikePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  PercentageStrikePayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_PercentageStrikePayoff", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PercentageStrikePayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PercentageStrikePayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (PercentageStrikePayoff *)new PercentageStrikePayoff(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PercentageStrikePayoff > *smartresult = result ? new ext::shared_ptr<  PercentageStrikePayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PercentageStrikePayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PercentageStrikePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PercentageStrikePayoff *arg1 = (PercentageStrikePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PercentageStrikePayoff > tempshared1 ;
  ext::shared_ptr< PercentageStrikePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PercentageStrikePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PercentageStrikePayoff" "', argument " "1"" of type '" "PercentageStrikePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PercentageStrikePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PercentageStrikePayoff > * >(argp1);
      arg1 = const_cast< PercentageStrikePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PercentageStrikePayoff > * >(argp1);
      arg1 = const_cast< PercentageStrikePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PercentageStrikePayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PercentageStrikePayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PercentageStrikePayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CashOrNothingPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  CashOrNothingPayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CashOrNothingPayoff", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CashOrNothingPayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CashOrNothingPayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CashOrNothingPayoff" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (CashOrNothingPayoff *)new CashOrNothingPayoff(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashOrNothingPayoff > *smartresult = result ? new ext::shared_ptr<  CashOrNothingPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashOrNothingPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CashOrNothingPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CashOrNothingPayoff *arg1 = (CashOrNothingPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CashOrNothingPayoff > tempshared1 ;
  ext::shared_ptr< CashOrNothingPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashOrNothingPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashOrNothingPayoff" "', argument " "1"" of type '" "CashOrNothingPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CashOrNothingPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CashOrNothingPayoff > * >(argp1);
      arg1 = const_cast< CashOrNothingPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CashOrNothingPayoff > * >(argp1);
      arg1 = const_cast< CashOrNothingPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashOrNothingPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CashOrNothingPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CashOrNothingPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AssetOrNothingPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  AssetOrNothingPayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AssetOrNothingPayoff", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AssetOrNothingPayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AssetOrNothingPayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (AssetOrNothingPayoff *)new AssetOrNothingPayoff(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AssetOrNothingPayoff > *smartresult = result ? new ext::shared_ptr<  AssetOrNothingPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AssetOrNothingPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AssetOrNothingPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AssetOrNothingPayoff *arg1 = (AssetOrNothingPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AssetOrNothingPayoff > tempshared1 ;
  ext::shared_ptr< AssetOrNothingPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AssetOrNothingPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AssetOrNothingPayoff" "', argument " "1"" of type '" "AssetOrNothingPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AssetOrNothingPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AssetOrNothingPayoff > * >(argp1);
      arg1 = const_cast< AssetOrNothingPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AssetOrNothingPayoff > * >(argp1);
      arg1 = const_cast< AssetOrNothingPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AssetOrNothingPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AssetOrNothingPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AssetOrNothingPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SuperSharePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SuperSharePayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SuperSharePayoff", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SuperSharePayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SuperSharePayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SuperSharePayoff" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (SuperSharePayoff *)new SuperSharePayoff(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SuperSharePayoff > *smartresult = result ? new ext::shared_ptr<  SuperSharePayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SuperSharePayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SuperSharePayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SuperSharePayoff *arg1 = (SuperSharePayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SuperSharePayoff > tempshared1 ;
  ext::shared_ptr< SuperSharePayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SuperSharePayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SuperSharePayoff" "', argument " "1"" of type '" "SuperSharePayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SuperSharePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SuperSharePayoff > * >(argp1);
      arg1 = const_cast< SuperSharePayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SuperSharePayoff > * >(argp1);
      arg1 = const_cast< SuperSharePayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SuperSharePayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SuperSharePayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SuperSharePayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GapPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  GapPayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GapPayoff", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GapPayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GapPayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GapPayoff" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (GapPayoff *)new GapPayoff(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GapPayoff > *smartresult = result ? new ext::shared_ptr<  GapPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GapPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GapPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GapPayoff *arg1 = (GapPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GapPayoff > tempshared1 ;
  ext::shared_ptr< GapPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GapPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GapPayoff" "', argument " "1"" of type '" "GapPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GapPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GapPayoff > * >(argp1);
      arg1 = const_cast< GapPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GapPayoff > * >(argp1);
      arg1 = const_cast< GapPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GapPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GapPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GapPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VanillaForwardPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  VanillaForwardPayoff *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VanillaForwardPayoff", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VanillaForwardPayoff" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VanillaForwardPayoff" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (VanillaForwardPayoff *)new VanillaForwardPayoff(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaForwardPayoff > *smartresult = result ? new ext::shared_ptr<  VanillaForwardPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaForwardPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VanillaForwardPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaForwardPayoff *arg1 = (VanillaForwardPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaForwardPayoff > tempshared1 ;
  ext::shared_ptr< VanillaForwardPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaForwardPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VanillaForwardPayoff" "', argument " "1"" of type '" "VanillaForwardPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaForwardPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaForwardPayoff > * >(argp1);
      arg1 = const_cast< VanillaForwardPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaForwardPayoff > * >(argp1);
      arg1 = const_cast< VanillaForwardPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VanillaForwardPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VanillaForwardPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VanillaForwardPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_BasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BasketPayoff *arg1 = (BasketPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BasketPayoff > tempshared1 ;
  ext::shared_ptr< BasketPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BasketPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasketPayoff" "', argument " "1"" of type '" "BasketPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BasketPayoff > * >(argp1);
      arg1 = const_cast< BasketPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BasketPayoff > * >(argp1);
      arg1 = const_cast< BasketPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BasketPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BasketPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MinBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MinBasketPayoff *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinBasketPayoff" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
  }
  {
    try {
      result = (MinBasketPayoff *)new MinBasketPayoff(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MinBasketPayoff > *smartresult = result ? new ext::shared_ptr<  MinBasketPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MinBasketPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MinBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MinBasketPayoff *arg1 = (MinBasketPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MinBasketPayoff > tempshared1 ;
  ext::shared_ptr< MinBasketPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MinBasketPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinBasketPayoff" "', argument " "1"" of type '" "MinBasketPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MinBasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MinBasketPayoff > * >(argp1);
      arg1 = const_cast< MinBasketPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MinBasketPayoff > * >(argp1);
      arg1 = const_cast< MinBasketPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MinBasketPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MinBasketPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MinBasketPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MaxBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MaxBasketPayoff *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxBasketPayoff" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
  }
  {
    try {
      result = (MaxBasketPayoff *)new MaxBasketPayoff(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MaxBasketPayoff > *smartresult = result ? new ext::shared_ptr<  MaxBasketPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MaxBasketPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MaxBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MaxBasketPayoff *arg1 = (MaxBasketPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MaxBasketPayoff > tempshared1 ;
  ext::shared_ptr< MaxBasketPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MaxBasketPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxBasketPayoff" "', argument " "1"" of type '" "MaxBasketPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MaxBasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MaxBasketPayoff > * >(argp1);
      arg1 = const_cast< MaxBasketPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MaxBasketPayoff > * >(argp1);
      arg1 = const_cast< MaxBasketPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MaxBasketPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MaxBasketPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MaxBasketPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AverageBasketPayoff__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > arg1 ;
  Array *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  AverageBasketPayoff *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AverageBasketPayoff" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AverageBasketPayoff" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AverageBasketPayoff" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (AverageBasketPayoff *)new AverageBasketPayoff(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AverageBasketPayoff > *smartresult = result ? new ext::shared_ptr<  AverageBasketPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AverageBasketPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AverageBasketPayoff__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > arg1 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AverageBasketPayoff *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AverageBasketPayoff" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AverageBasketPayoff" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (AverageBasketPayoff *)new AverageBasketPayoff(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AverageBasketPayoff > *smartresult = result ? new ext::shared_ptr<  AverageBasketPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AverageBasketPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AverageBasketPayoff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AverageBasketPayoff", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Payoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AverageBasketPayoff__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Payoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_new_AverageBasketPayoff__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AverageBasketPayoff'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AverageBasketPayoff::AverageBasketPayoff(ext::shared_ptr< Payoff > const,Array const &)\n"
    "    AverageBasketPayoff::AverageBasketPayoff(ext::shared_ptr< Payoff > const,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AverageBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AverageBasketPayoff *arg1 = (AverageBasketPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AverageBasketPayoff > tempshared1 ;
  ext::shared_ptr< AverageBasketPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AverageBasketPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AverageBasketPayoff" "', argument " "1"" of type '" "AverageBasketPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AverageBasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AverageBasketPayoff > * >(argp1);
      arg1 = const_cast< AverageBasketPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AverageBasketPayoff > * >(argp1);
      arg1 = const_cast< AverageBasketPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AverageBasketPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AverageBasketPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AverageBasketPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpreadBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SpreadBasketPayoff *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadBasketPayoff" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
  }
  {
    try {
      result = (SpreadBasketPayoff *)new SpreadBasketPayoff(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadBasketPayoff > *smartresult = result ? new ext::shared_ptr<  SpreadBasketPayoff >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadBasketPayoff_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SpreadBasketPayoff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SpreadBasketPayoff *arg1 = (SpreadBasketPayoff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SpreadBasketPayoff > tempshared1 ;
  ext::shared_ptr< SpreadBasketPayoff > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SpreadBasketPayoff_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadBasketPayoff" "', argument " "1"" of type '" "SpreadBasketPayoff *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SpreadBasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SpreadBasketPayoff > * >(argp1);
      arg1 = const_cast< SpreadBasketPayoff * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SpreadBasketPayoff > * >(argp1);
      arg1 = const_cast< SpreadBasketPayoff * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadBasketPayoff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SpreadBasketPayoff_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpreadBasketPayoff_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BasketOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BasketPayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BasketPayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  PyObject *swig_obj[2] ;
  BasketOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BasketOption", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BasketPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasketOption" "', argument " "1"" of type '" "ext::shared_ptr< BasketPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BasketPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BasketPayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BasketOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (BasketOption *)new BasketOption((ext::shared_ptr< BasketPayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BasketOption > *smartresult = result ? new ext::shared_ptr<  BasketOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BasketOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BasketOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BasketOption *arg1 = (BasketOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BasketOption > tempshared1 ;
  ext::shared_ptr< BasketOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BasketOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasketOption" "', argument " "1"" of type '" "BasketOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BasketOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BasketOption > * >(argp1);
      arg1 = const_cast< BasketOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BasketOption > * >(argp1);
      arg1 = const_cast< BasketOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BasketOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BasketOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BasketOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPREuropeanBasketEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanBasketEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPREuropeanBasketEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPREuropeanBasketEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPREuropeanBasketEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPREuropeanBasketEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPREuropeanBasketEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCEuropeanBasketEngine< PseudoRandom > *)new_MCEuropeanBasketEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPREuropeanBasketEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanBasketEngine< PseudoRandom > *arg1 = (MCEuropeanBasketEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPREuropeanBasketEngine" "', argument " "1"" of type '" "MCEuropeanBasketEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanBasketEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanBasketEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEuropeanBasketEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPREuropeanBasketEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPREuropeanBasketEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDEuropeanBasketEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEuropeanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDEuropeanBasketEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDEuropeanBasketEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDEuropeanBasketEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDEuropeanBasketEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDEuropeanBasketEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCEuropeanBasketEngine< LowDiscrepancy > *)new_MCEuropeanBasketEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDEuropeanBasketEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEuropeanBasketEngine< LowDiscrepancy > *arg1 = (MCEuropeanBasketEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDEuropeanBasketEngine" "', argument " "1"" of type '" "MCEuropeanBasketEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanBasketEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEuropeanBasketEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEuropeanBasketEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDEuropeanBasketEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDEuropeanBasketEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRAmericanBasketEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  Size arg10 = (Size) Null< Size >() ;
  Size arg11 = (Size) 2 ;
  LsmBasisSystem::PolynomialType arg12 = (LsmBasisSystem::PolynomialType) LsmBasisSystem::Monomial ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"nCalibrationSamples",  (char *)"polynomOrder",  (char *)"polynomType",  NULL 
  };
  MCAmericanBasketEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOOOO:new_MCPRAmericanBasketEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_size_t(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "10"" of type '" "Size""'");
    } 
    arg10 = static_cast< Size >(val10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_size_t(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "11"" of type '" "Size""'");
    } 
    arg11 = static_cast< Size >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_MCPRAmericanBasketEngine" "', argument " "12"" of type '" "LsmBasisSystem::PolynomialType""'");
    } 
    arg12 = static_cast< LsmBasisSystem::PolynomialType >(val12);
  }
  {
    try {
      result = (MCAmericanBasketEngine< PseudoRandom > *)new_MCAmericanBasketEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(arg10),SWIG_STD_MOVE(arg11),arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRAmericanBasketEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCAmericanBasketEngine< PseudoRandom > *arg1 = (MCAmericanBasketEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRAmericanBasketEngine" "', argument " "1"" of type '" "MCAmericanBasketEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCAmericanBasketEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCAmericanBasketEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCAmericanBasketEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRAmericanBasketEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRAmericanBasketEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDAmericanBasketEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  intOrNull arg2 = (intOrNull) Null< Size >() ;
  intOrNull arg3 = (intOrNull) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  Size arg10 = (Size) Null< Size >() ;
  Size arg11 = (Size) 2 ;
  LsmBasisSystem::PolynomialType arg12 = (LsmBasisSystem::PolynomialType) LsmBasisSystem::Monomial ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  (char *)"nCalibrationSamples",  (char *)"polynomOrder",  (char *)"polynomType",  NULL 
  };
  MCAmericanBasketEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOOOOO:new_MCLDAmericanBasketEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<int>();
      else if (PyInt_Check(obj1))
      arg2 = int(PyInt_AsLong(obj1));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<int>();
      else if (PyInt_Check(obj2))
      arg3 = int(PyInt_AsLong(obj2));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_size_t(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "10"" of type '" "Size""'");
    } 
    arg10 = static_cast< Size >(val10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_size_t(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "11"" of type '" "Size""'");
    } 
    arg11 = static_cast< Size >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_MCLDAmericanBasketEngine" "', argument " "12"" of type '" "LsmBasisSystem::PolynomialType""'");
    } 
    arg12 = static_cast< LsmBasisSystem::PolynomialType >(val12);
  }
  {
    try {
      result = (MCAmericanBasketEngine< LowDiscrepancy > *)new_MCAmericanBasketEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9,SWIG_STD_MOVE(arg10),SWIG_STD_MOVE(arg11),arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDAmericanBasketEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCAmericanBasketEngine< LowDiscrepancy > *arg1 = (MCAmericanBasketEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDAmericanBasketEngine" "', argument " "1"" of type '" "MCAmericanBasketEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCAmericanBasketEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCAmericanBasketEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCAmericanBasketEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDAmericanBasketEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDAmericanBasketEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StulzEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  StulzEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_StulzEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StulzEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StulzEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StulzEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (StulzEngine *)new StulzEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StulzEngine > *smartresult = result ? new ext::shared_ptr<  StulzEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StulzEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StulzEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StulzEngine *arg1 = (StulzEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StulzEngine > tempshared1 ;
  ext::shared_ptr< StulzEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StulzEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StulzEngine" "', argument " "1"" of type '" "StulzEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StulzEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StulzEngine > * >(argp1);
      arg1 = const_cast< StulzEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StulzEngine > * >(argp1);
      arg1 = const_cast< StulzEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StulzEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StulzEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StulzEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KirkEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BlackProcess > *arg1 = 0 ;
  ext::shared_ptr< BlackProcess > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< BlackProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  KirkEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KirkEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KirkEngine" "', argument " "1"" of type '" "ext::shared_ptr< BlackProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KirkEngine" "', argument " "2"" of type '" "ext::shared_ptr< BlackProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KirkEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (KirkEngine *)new KirkEngine((ext::shared_ptr< BlackProcess > const &)*arg1,(ext::shared_ptr< BlackProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KirkEngine > *smartresult = result ? new ext::shared_ptr<  KirkEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KirkEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KirkEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KirkEngine *arg1 = (KirkEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KirkEngine > tempshared1 ;
  ext::shared_ptr< KirkEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KirkEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KirkEngine" "', argument " "1"" of type '" "KirkEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  KirkEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  KirkEngine > * >(argp1);
      arg1 = const_cast< KirkEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  KirkEngine > * >(argp1);
      arg1 = const_cast< KirkEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KirkEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_KirkEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KirkEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  bool arg9 ;
  Real arg10 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  bool arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  FdmSchemeDesc *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "8"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg8 = reinterpret_cast< FdmSchemeDesc * >(argp8);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,(FdmSchemeDesc const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  Fd2dBlackScholesVanillaEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fd2dBlackScholesVanillaEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Fd2dBlackScholesVanillaEngine *)new Fd2dBlackScholesVanillaEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > *smartresult = result ? new ext::shared_ptr<  Fd2dBlackScholesVanillaEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fd2dBlackScholesVanillaEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fd2dBlackScholesVanillaEngine", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_Fd2dBlackScholesVanillaEngine__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fd2dBlackScholesVanillaEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Size,Size,Size,FdmSchemeDesc const &,bool,Real)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Size,Size,Size,FdmSchemeDesc const &,bool)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Size,Size,Size,FdmSchemeDesc const &)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Size,Size,Size)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Size,Size)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size,Size)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Size)\n"
    "    Fd2dBlackScholesVanillaEngine::Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fd2dBlackScholesVanillaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fd2dBlackScholesVanillaEngine *arg1 = (Fd2dBlackScholesVanillaEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fd2dBlackScholesVanillaEngine > tempshared1 ;
  ext::shared_ptr< Fd2dBlackScholesVanillaEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fd2dBlackScholesVanillaEngine" "', argument " "1"" of type '" "Fd2dBlackScholesVanillaEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > * >(argp1);
      arg1 = const_cast< Fd2dBlackScholesVanillaEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fd2dBlackScholesVanillaEngine > * >(argp1);
      arg1 = const_cast< Fd2dBlackScholesVanillaEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fd2dBlackScholesVanillaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fd2dBlackScholesVanillaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EverestOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Rate arg2 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  EverestOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_EverestOption", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EverestOption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EverestOption" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EverestOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (EverestOption *)new EverestOption(arg1,arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EverestOption > *smartresult = result ? new ext::shared_ptr<  EverestOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EverestOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EverestOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EverestOption *arg1 = (EverestOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EverestOption > tempshared1 ;
  ext::shared_ptr< EverestOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EverestOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EverestOption" "', argument " "1"" of type '" "EverestOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EverestOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EverestOption > * >(argp1);
      arg1 = const_cast< EverestOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EverestOption > * >(argp1);
      arg1 = const_cast< EverestOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EverestOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EverestOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EverestOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPREverestEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 = (Size) Null< Size >() ;
  Size arg3 = (Size) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEverestEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCPREverestEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPREverestEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPREverestEngine" "', argument " "2"" of type '" "Size""'");
    } 
    arg2 = static_cast< Size >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_size_t(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCPREverestEngine" "', argument " "3"" of type '" "Size""'");
    } 
    arg3 = static_cast< Size >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCPREverestEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCPREverestEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCPREverestEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCEverestEngine< PseudoRandom > *)new_MCEverestEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEverestEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCEverestEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPREverestEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEverestEngine< PseudoRandom > *arg1 = (MCEverestEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEverestEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCEverestEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPREverestEngine" "', argument " "1"" of type '" "MCEverestEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEverestEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEverestEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEverestEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEverestEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCEverestEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPREverestEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPREverestEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDEverestEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  Size arg2 = (Size) Null< Size >() ;
  Size arg3 = (Size) Null< Size >() ;
  bool arg4 = (bool) false ;
  bool arg5 = (bool) false ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  doubleOrNull arg7 = (doubleOrNull) Null< Real >() ;
  intOrNull arg8 = (intOrNull) Null< Size >() ;
  BigInteger arg9 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  long 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 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"timeSteps",  (char *)"timeStepsPerYear",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCEverestEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOOOO:new_MCLDEverestEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDEverestEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDEverestEngine" "', argument " "2"" of type '" "Size""'");
    } 
    arg2 = static_cast< Size >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_size_t(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCLDEverestEngine" "', argument " "3"" of type '" "Size""'");
    } 
    arg3 = static_cast< Size >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_bool(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MCLDEverestEngine" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_bool(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MCLDEverestEngine" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    {
      if (obj6 == Py_None)
      arg7 = Null<double>();
      else if (PyFloat_Check(obj6))
      arg7 = PyFloat_AsDouble(obj6);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj7) {
    {
      if (obj7 == Py_None)
      arg8 = Null<int>();
      else if (PyInt_Check(obj7))
      arg8 = int(PyInt_AsLong(obj7));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_long(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_MCLDEverestEngine" "', argument " "9"" of type '" "BigInteger""'");
    } 
    arg9 = static_cast< BigInteger >(val9);
  }
  {
    try {
      result = (MCEverestEngine< LowDiscrepancy > *)new_MCEverestEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDEverestEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCEverestEngine< LowDiscrepancy > *arg1 = (MCEverestEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDEverestEngine" "', argument " "1"" of type '" "MCEverestEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEverestEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCEverestEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCEverestEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDEverestEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDEverestEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HimalayaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Real arg2 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  HimalayaOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HimalayaOption", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HimalayaOption" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HimalayaOption" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HimalayaOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (HimalayaOption *)new HimalayaOption((std::vector< Date,std::allocator< Date > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HimalayaOption > *smartresult = result ? new ext::shared_ptr<  HimalayaOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HimalayaOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HimalayaOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HimalayaOption *arg1 = (HimalayaOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HimalayaOption > tempshared1 ;
  ext::shared_ptr< HimalayaOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HimalayaOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HimalayaOption" "', argument " "1"" of type '" "HimalayaOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HimalayaOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HimalayaOption > * >(argp1);
      arg1 = const_cast< HimalayaOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HimalayaOption > * >(argp1);
      arg1 = const_cast< HimalayaOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HimalayaOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HimalayaOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HimalayaOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRHimalayaEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCHimalayaEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCPRHimalayaEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRHimalayaEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRHimalayaEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCPRHimalayaEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCPRHimalayaEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCHimalayaEngine< PseudoRandom > *)new_MCHimalayaEngine_Sl_PseudoRandom_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRHimalayaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCHimalayaEngine< PseudoRandom > *arg1 = (MCHimalayaEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRHimalayaEngine" "', argument " "1"" of type '" "MCHimalayaEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCHimalayaEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCHimalayaEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCHimalayaEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRHimalayaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRHimalayaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDHimalayaEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcessArray > *arg1 = 0 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcessArray > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCHimalayaEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCLDHimalayaEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcessArray_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDHimalayaEngine" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcessArray > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcessArray > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDHimalayaEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCLDHimalayaEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCLDHimalayaEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCHimalayaEngine< LowDiscrepancy > *)new_MCHimalayaEngine_Sl_LowDiscrepancy_Sg_((ext::shared_ptr< StochasticProcessArray > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDHimalayaEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCHimalayaEngine< LowDiscrepancy > *arg1 = (MCHimalayaEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDHimalayaEngine" "', argument " "1"" of type '" "MCHimalayaEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCHimalayaEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCHimalayaEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCHimalayaEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDHimalayaEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDHimalayaEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_blackFormula__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormula" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormula" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormula" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormula" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormula" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormula" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)blackFormula(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormula__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormula" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormula" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormula" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormula" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormula" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)blackFormula(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormula__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormula" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormula" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormula" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormula" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormula(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormula(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "blackFormula", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormula__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_blackFormula__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_blackFormula__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'blackFormula'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    blackFormula(Option::Type,Real,Real,Real,Real,Real)\n"
    "    blackFormula(Option::Type,Real,Real,Real,Real)\n"
    "    blackFormula(Option::Type,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Natural arg9 ;
  int 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 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDev" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDev" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDev" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDev" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDev" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDev" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDev" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDev" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "blackFormulaImpliedStdDev" "', argument " "9"" of type '" "Natural""'");
  } 
  arg9 = static_cast< Natural >(val9);
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDev" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDev" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDev" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDev" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDev" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDev" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDev" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDev" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDev" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDev" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDev" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDev" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDev" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDev" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDev" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDev" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDev" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDev" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDev" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDev" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDev" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDev" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDev" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDev" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDev" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDev" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDev" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDev" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDev" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDev" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaImpliedStdDev(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDev(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "blackFormulaImpliedStdDev", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaImpliedStdDev__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_blackFormulaImpliedStdDev__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_blackFormulaImpliedStdDev__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_blackFormulaImpliedStdDev__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_blackFormulaImpliedStdDev__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_blackFormulaImpliedStdDev__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'blackFormulaImpliedStdDev'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    blackFormulaImpliedStdDev(Option::Type,Real,Real,Real,Real,Real,Real,Real,Natural)\n"
    "    blackFormulaImpliedStdDev(Option::Type,Real,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDev(Option::Type,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDev(Option::Type,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDev(Option::Type,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDev(Option::Type,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  Natural arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  unsigned int val10 ;
  int ecode10 = 0 ;
  Real result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "10"" of type '" "Natural""'");
  } 
  arg10 = static_cast< Natural >(val10);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Real arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  Natural arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  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 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "9"" of type '" "Natural""'");
  } 
  arg9 = static_cast< Natural >(val9);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  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 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  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 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  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 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaImpliedStdDevLiRS" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)blackFormulaImpliedStdDevLiRS((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaImpliedStdDevLiRS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "blackFormulaImpliedStdDevLiRS", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_13(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_12(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_11(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_10(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_9(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_8(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_7(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_blackFormulaImpliedStdDevLiRS__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'blackFormulaImpliedStdDevLiRS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real,Real,Real,Real,Real,Real,Natural)\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(Option::Type,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real,Real,Real,Real,Real,Natural)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real)\n"
    "    blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_blackFormulaCashItmProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaCashItmProbability" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaCashItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaCashItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaCashItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaCashItmProbability" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)blackFormulaCashItmProbability(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaCashItmProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaCashItmProbability" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaCashItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaCashItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaCashItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaCashItmProbability(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaCashItmProbability__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaCashItmProbability" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaCashItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaCashItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaCashItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaCashItmProbability((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaCashItmProbability__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaCashItmProbability" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaCashItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaCashItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)blackFormulaCashItmProbability((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaCashItmProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "blackFormulaCashItmProbability", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_blackFormulaCashItmProbability__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaCashItmProbability__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaCashItmProbability__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_blackFormulaCashItmProbability__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'blackFormulaCashItmProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    blackFormulaCashItmProbability(Option::Type,Real,Real,Real,Real)\n"
    "    blackFormulaCashItmProbability(Option::Type,Real,Real,Real)\n"
    "    blackFormulaCashItmProbability(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real)\n"
    "    blackFormulaCashItmProbability(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_blackFormulaAssetItmProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaAssetItmProbability" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaAssetItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaAssetItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaAssetItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "blackFormulaAssetItmProbability" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)blackFormulaAssetItmProbability(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaAssetItmProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "blackFormulaAssetItmProbability" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaAssetItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaAssetItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaAssetItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaAssetItmProbability(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaAssetItmProbability__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaAssetItmProbability" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaAssetItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaAssetItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "blackFormulaAssetItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)blackFormulaAssetItmProbability((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaAssetItmProbability__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "blackFormulaAssetItmProbability" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "blackFormulaAssetItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "blackFormulaAssetItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)blackFormulaAssetItmProbability((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_blackFormulaAssetItmProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "blackFormulaAssetItmProbability", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_blackFormulaAssetItmProbability__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaAssetItmProbability__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_blackFormulaAssetItmProbability__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_blackFormulaAssetItmProbability__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'blackFormulaAssetItmProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    blackFormulaAssetItmProbability(Option::Type,Real,Real,Real,Real)\n"
    "    blackFormulaAssetItmProbability(Option::Type,Real,Real,Real)\n"
    "    blackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real,Real)\n"
    "    blackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormula__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bachelierBlackFormula" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bachelierBlackFormula" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bachelierBlackFormula" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bachelierBlackFormula" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "bachelierBlackFormula" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)bachelierBlackFormula(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormula__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bachelierBlackFormula" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bachelierBlackFormula" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bachelierBlackFormula" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bachelierBlackFormula" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)bachelierBlackFormula(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormula(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bachelierBlackFormula", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_bachelierBlackFormula__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_bachelierBlackFormula__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bachelierBlackFormula'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    bachelierBlackFormula(Option::Type,Real,Real,Real,Real)\n"
    "    bachelierBlackFormula(Option::Type,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormulaImpliedVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  int 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 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Real)bachelierBlackFormulaImpliedVol(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormulaImpliedVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "bachelierBlackFormulaImpliedVol" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)bachelierBlackFormulaImpliedVol(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormulaImpliedVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bachelierBlackFormulaImpliedVol", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_bachelierBlackFormulaImpliedVol__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_bachelierBlackFormulaImpliedVol__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bachelierBlackFormulaImpliedVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    bachelierBlackFormulaImpliedVol(Option::Type,Real,Real,Real,Real,Real)\n"
    "    bachelierBlackFormulaImpliedVol(Option::Type,Real,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormulaAssetItmProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)bachelierBlackFormulaAssetItmProbability(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormulaAssetItmProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bachelierBlackFormulaAssetItmProbability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)bachelierBlackFormulaAssetItmProbability((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bachelierBlackFormulaAssetItmProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bachelierBlackFormulaAssetItmProbability", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_bachelierBlackFormulaAssetItmProbability__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_bachelierBlackFormulaAssetItmProbability__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bachelierBlackFormulaAssetItmProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    bachelierBlackFormulaAssetItmProbability(Option::Type,Real,Real,Real)\n"
    "    bachelierBlackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BlackDeltaCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Option::Type arg1 ;
  DeltaVolQuote::DeltaType arg2 ;
  Real arg3 ;
  DiscountFactor arg4 ;
  DiscountFactor arg5 ;
  Real arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  BlackDeltaCalculator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackDeltaCalculator", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BlackDeltaCalculator" "', argument " "1"" of type '" "Option::Type""'");
  } 
  arg1 = static_cast< Option::Type >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackDeltaCalculator" "', argument " "2"" of type '" "DeltaVolQuote::DeltaType""'");
  } 
  arg2 = static_cast< DeltaVolQuote::DeltaType >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackDeltaCalculator" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BlackDeltaCalculator" "', argument " "4"" of type '" "DiscountFactor""'");
  } 
  arg4 = static_cast< DiscountFactor >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BlackDeltaCalculator" "', argument " "5"" of type '" "DiscountFactor""'");
  } 
  arg5 = static_cast< DiscountFactor >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_BlackDeltaCalculator" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (BlackDeltaCalculator *)new BlackDeltaCalculator(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BlackDeltaCalculator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackDeltaCalculator_deltaFromStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackDeltaCalculator_deltaFromStrike", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackDeltaCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackDeltaCalculator_deltaFromStrike" "', argument " "1"" of type '" "BlackDeltaCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackDeltaCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackDeltaCalculator_deltaFromStrike" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((BlackDeltaCalculator const *)arg1)->deltaFromStrike(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackDeltaCalculator_strikeFromDelta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackDeltaCalculator_strikeFromDelta", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackDeltaCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackDeltaCalculator_strikeFromDelta" "', argument " "1"" of type '" "BlackDeltaCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackDeltaCalculator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackDeltaCalculator_strikeFromDelta" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((BlackDeltaCalculator const *)arg1)->strikeFromDelta(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackDeltaCalculator_atmStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  DeltaVolQuote::AtmType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackDeltaCalculator_atmStrike", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackDeltaCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackDeltaCalculator_atmStrike" "', argument " "1"" of type '" "BlackDeltaCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< BlackDeltaCalculator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackDeltaCalculator_atmStrike" "', argument " "2"" of type '" "DeltaVolQuote::AtmType""'");
  } 
  arg2 = static_cast< DeltaVolQuote::AtmType >(val2);
  {
    try {
      result = (Real)((BlackDeltaCalculator const *)arg1)->atmStrike(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackDeltaCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackDeltaCalculator *arg1 = (BlackDeltaCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BlackDeltaCalculator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackDeltaCalculator" "', argument " "1"" of type '" "BlackDeltaCalculator *""'"); 
  }
  arg1 = reinterpret_cast< BlackDeltaCalculator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackDeltaCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BlackDeltaCalculator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackDeltaCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TimeBasket__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TimeBasket *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (TimeBasket *)new TimeBasket();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeBasket, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeBasket__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  TimeBasket *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeBasket" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeBasket" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TimeBasket" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeBasket" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (TimeBasket *)new TimeBasket((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeBasket, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeBasket(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TimeBasket", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TimeBasket__SWIG_0(self, argc, argv);
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TimeBasket__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TimeBasket'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TimeBasket::TimeBasket()\n"
    "    TimeBasket::TimeBasket(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeBasket___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket___len__" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  {
    try {
      result = (arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeBasket_rebin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  TimeBasket result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeBasket_rebin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket_rebin" "', argument " "1"" of type '" "TimeBasket const *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeBasket_rebin" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeBasket_rebin" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = ((TimeBasket const *)arg1)->rebin((std::vector< Date,std::allocator< Date > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeBasket(result)), SWIGTYPE_p_TimeBasket, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeBasket___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeBasket___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket___getitem__" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeBasket___getitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeBasket___getitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)TimeBasket___getitem__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeBasket___setitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeBasket___setitem__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket___setitem__" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeBasket___setitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeBasket___setitem__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeBasket___setitem__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      TimeBasket___setitem__(arg1,(Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeBasket_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket_items" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  {
    try {
      result = (PyObject *)TimeBasket_items(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeBasket___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeBasket___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket___contains__" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeBasket___contains__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeBasket___contains__" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (bool)TimeBasket___contains__(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeBasket___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeBasket___iter__" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  {
    try {
      result = (PyObject *)TimeBasket___iter__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TimeBasket(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TimeBasket *arg1 = (TimeBasket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TimeBasket, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeBasket" "', argument " "1"" of type '" "TimeBasket *""'"); 
  }
  arg1 = reinterpret_cast< TimeBasket * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeBasket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TimeBasket, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TimeBasket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Swap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  Swap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Swap *)new Swap((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swap > *smartresult = result ? new ext::shared_ptr<  Swap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Leg,std::allocator< Leg > > *arg1 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  Swap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *ptr = (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Swap" "', argument " "1"" of type '" "std::vector< Leg,std::allocator< Leg > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Swap" "', argument " "1"" of type '" "std::vector< Leg,std::allocator< Leg > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Swap" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Swap" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Swap *)new Swap((std::vector< Leg,std::allocator< Leg > > const &)*arg1,(std::vector< bool,std::allocator< bool > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swap > *smartresult = result ? new ext::shared_ptr<  Swap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Swap", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Swap__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >,std::allocator< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector<bool,std::allocator< bool > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Swap__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Swap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Swap::Swap(std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &,std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)\n"
    "    Swap::Swap(std::vector< Leg,std::allocator< Leg > > const &,std::vector< bool,std::allocator< bool > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Swap_numberOfLegs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_numberOfLegs" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Swap const *)arg1)->numberOfLegs();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_startDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_startDate" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Swap const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_maturityDate" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Swap const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_leg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap > tempshared1 ;
  ext::shared_ptr< Swap > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Leg *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Swap_leg", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_leg" "', argument " "1"" of type '" "Swap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swap_leg" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Leg *) &(arg1)->leg(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_legNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Swap_legNPV", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_legNPV" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swap_legNPV" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)((Swap const *)arg1)->legNPV(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_legBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Swap_legBPS", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_legBPS" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swap_legBPS" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)((Swap const *)arg1)->legBPS(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_startDiscounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DiscountFactor result;
  
  if (!SWIG_Python_UnpackTuple(args, "Swap_startDiscounts", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_startDiscounts" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swap_startDiscounts" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (DiscountFactor)((Swap const *)arg1)->startDiscounts(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_endDiscounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DiscountFactor result;
  
  if (!SWIG_Python_UnpackTuple(args, "Swap_endDiscounts", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_endDiscounts" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swap_endDiscounts" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (DiscountFactor)((Swap const *)arg1)->endDiscounts(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_npvDateDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DiscountFactor result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_npvDateDiscount" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DiscountFactor)((Swap const *)arg1)->npvDateDiscount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swap_payer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap const > tempshared1 ;
  ext::shared_ptr< Swap const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Swap_payer", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swap_payer" "', argument " "1"" of type '" "Swap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swap_payer" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (bool)((Swap const *)arg1)->payer(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swap *arg1 = (Swap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap > tempshared1 ;
  ext::shared_ptr< Swap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Swap" "', argument " "1"" of type '" "Swap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      arg1 = const_cast< Swap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Swap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Swap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Swap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_simplifyNotificationGraph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Swap &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Swap &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      arg1 = const_cast< Swap * >(reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simplifyNotificationGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      simplifyNotificationGraph(*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplifyNotificationGraph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swap > tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Swap &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Swap &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1);
      arg1 = const_cast< Swap * >(tempshared1.get());
    } else {
      arg1 = const_cast< Swap * >(reinterpret_cast< ext::shared_ptr<  Swap > * >(argp1)->get());
    }
  }
  {
    try {
      simplifyNotificationGraph(*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VanillaSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Spread arg8 ;
  DayCounter *arg9 = 0 ;
  ext::optional< bool > arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  VanillaSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VanillaSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VanillaSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VanillaSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VanillaSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VanillaSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VanillaSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_VanillaSwap" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VanillaSwap" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_VanillaSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  
  if(swig_obj[9] == Py_None)
  arg10 = ext::nullopt;
  else if (swig_obj[9] == Py_True)
  arg10 = true;
  else
  arg10 = false;
  
  {
    try {
      result = (VanillaSwap *)new_VanillaSwap__SWIG_0(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,arg8,(DayCounter const &)*arg9,SWIG_STD_MOVE(arg10));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwap > *smartresult = result ? new ext::shared_ptr<  VanillaSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VanillaSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Spread arg8 ;
  DayCounter *arg9 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  VanillaSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VanillaSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VanillaSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VanillaSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VanillaSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_VanillaSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_VanillaSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_VanillaSwap" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_VanillaSwap" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_VanillaSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VanillaSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  {
    try {
      result = (VanillaSwap *)new_VanillaSwap__SWIG_0(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,arg8,(DayCounter const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwap > *smartresult = result ? new ext::shared_ptr<  VanillaSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VanillaSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_VanillaSwap", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_VanillaSwap__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        if (PyBool_Check(argv[9]) || Py_None == argv[9]) 
                        _v = 1;
                        else
                        _v = 0;
                      }
                      if (_v) {
                        return _wrap_new_VanillaSwap__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VanillaSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    VanillaSwap::VanillaSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,Schedule const &,ext::shared_ptr< IborIndex > const &,Spread,DayCounter const &,ext::optional< bool >)\n"
    "    VanillaSwap::VanillaSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,Schedule const &,ext::shared_ptr< IborIndex > const &,Spread,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap const > tempshared1 ;
  ext::shared_ptr< VanillaSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_type" "', argument " "1"" of type '" "VanillaSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)((VanillaSwap const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fairRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fairRate" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fairSpread" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fixedLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fixedLegBPS" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fixedLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_floatingLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_floatingLegBPS" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->floatingLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fixedLegNPV" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_floatingLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_floatingLegNPV" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->floatingLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fixedLeg" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_floatingLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_floatingLeg" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_nominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_nominal" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->nominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fixedSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Schedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fixedSchedule" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Schedule *) &(arg1)->fixedSchedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_floatingSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Schedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_floatingSchedule" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Schedule *) &(arg1)->floatingSchedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fixedRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fixedRate" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_spread" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_floatingDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_floatingDayCount" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &(arg1)->floatingDayCount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VanillaSwap_fixedDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VanillaSwap_fixedDayCount" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &(arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VanillaSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwap *arg1 = (VanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  ext::shared_ptr< VanillaSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VanillaSwap" "', argument " "1"" of type '" "VanillaSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwap > * >(argp1);
      arg1 = const_cast< VanillaSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VanillaSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VanillaSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap__MakeVanillaSwap_receiveFixed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_receiveFixed" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_receiveFixed" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->receiveFixed(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_receiveFixed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_receiveFixed" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->receiveFixed();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_receiveFixed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_receiveFixed", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeVanillaSwap_receiveFixed__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeVanillaSwap_receiveFixed__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeVanillaSwap_receiveFixed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeVanillaSwap::receiveFixed(bool)\n"
    "    MakeVanillaSwap::receiveFixed()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Swap::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withType" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withType" "', argument " "2"" of type '" "Swap::Type""'");
  } 
  arg2 = static_cast< Swap::Type >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withType(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withNominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withNominal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withNominal" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withNominal" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withNominal(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withSettlementDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Natural arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withSettlementDays", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withSettlementDays" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withSettlementDays" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withSettlementDays(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withEffectiveDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withEffectiveDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withEffectiveDate" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withEffectiveDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withEffectiveDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withEffectiveDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withTerminationDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withTerminationDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withTerminationDate" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withTerminationDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withTerminationDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withTerminationDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withRule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DateGeneration::Rule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withRule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withRule" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withRule" "', argument " "2"" of type '" "DateGeneration::Rule""'");
  } 
  arg2 = static_cast< DateGeneration::Rule >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withRule(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegTenor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegTenor" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFixedLegTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFixedLegTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegCalendar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegCalendar" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFixedLegCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFixedLegCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegCalendar((Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegConvention", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegConvention" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFixedLegConvention" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegConvention(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegTerminationDateConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegTerminationDateConvention", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegTerminationDateConvention" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFixedLegTerminationDateConvention" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegTerminationDateConvention(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegRule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DateGeneration::Rule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegRule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegRule" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFixedLegRule" "', argument " "2"" of type '" "DateGeneration::Rule""'");
  } 
  arg2 = static_cast< DateGeneration::Rule >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegRule(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegEndOfMonth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegEndOfMonth" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFixedLegEndOfMonth" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegEndOfMonth(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegEndOfMonth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegEndOfMonth" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegEndOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegEndOfMonth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegEndOfMonth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeVanillaSwap_withFixedLegEndOfMonth__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeVanillaSwap_withFixedLegEndOfMonth__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeVanillaSwap_withFixedLegEndOfMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeVanillaSwap::withFixedLegEndOfMonth(bool)\n"
    "    MakeVanillaSwap::withFixedLegEndOfMonth()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegFirstDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegFirstDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegFirstDate" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFixedLegFirstDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFixedLegFirstDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegFirstDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegNextToLastDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegNextToLastDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegNextToLastDate" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFixedLegNextToLastDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFixedLegNextToLastDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegNextToLastDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFixedLegDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DayCounter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFixedLegDayCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFixedLegDayCount" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFixedLegDayCount" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFixedLegDayCount" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFixedLegDayCount((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegTenor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegTenor" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFloatingLegTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFloatingLegTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegCalendar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegCalendar" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFloatingLegCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFloatingLegCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegCalendar((Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegConvention", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegConvention" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFloatingLegConvention" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegConvention(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegTerminationDateConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegTerminationDateConvention", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegTerminationDateConvention" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFloatingLegTerminationDateConvention" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegTerminationDateConvention(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegRule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DateGeneration::Rule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegRule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegRule" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFloatingLegRule" "', argument " "2"" of type '" "DateGeneration::Rule""'");
  } 
  arg2 = static_cast< DateGeneration::Rule >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegRule(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegEndOfMonth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegEndOfMonth" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFloatingLegEndOfMonth" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegEndOfMonth(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegEndOfMonth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegEndOfMonth" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegEndOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegEndOfMonth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegEndOfMonth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeVanillaSwap_withFloatingLegEndOfMonth__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeVanillaSwap_withFloatingLegEndOfMonth__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeVanillaSwap_withFloatingLegEndOfMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeVanillaSwap::withFloatingLegEndOfMonth(bool)\n"
    "    MakeVanillaSwap::withFloatingLegEndOfMonth()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegFirstDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegFirstDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegFirstDate" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFloatingLegFirstDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFloatingLegFirstDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegFirstDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegNextToLastDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegNextToLastDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegNextToLastDate" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFloatingLegNextToLastDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFloatingLegNextToLastDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegNextToLastDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  DayCounter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegDayCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegDayCount" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withFloatingLegDayCount" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withFloatingLegDayCount" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegDayCount((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withFloatingLegSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Spread arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withFloatingLegSpread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withFloatingLegSpread" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withFloatingLegSpread" "', argument " "2"" of type '" "Spread""'");
  } 
  arg2 = static_cast< Spread >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withFloatingLegSpread(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withDiscountingTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withDiscountingTermStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withDiscountingTermStructure" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withDiscountingTermStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeVanillaSwap_withDiscountingTermStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withDiscountingTermStructure((Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withPricingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared2 ;
  PyObject *swig_obj[2] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withPricingEngine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withPricingEngine" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeVanillaSwap_withPricingEngine" "', argument " "2"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withPricingEngine((ext::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withIndexedCoupons__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withIndexedCoupons" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withIndexedCoupons" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withIndexedCoupons(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withIndexedCoupons__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withIndexedCoupons" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withIndexedCoupons();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withIndexedCoupons(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withIndexedCoupons", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeVanillaSwap_withIndexedCoupons__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeVanillaSwap_withIndexedCoupons__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeVanillaSwap_withIndexedCoupons'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeVanillaSwap::withIndexedCoupons(bool)\n"
    "    MakeVanillaSwap::withIndexedCoupons()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withAtParCoupons__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withAtParCoupons" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeVanillaSwap_withAtParCoupons" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withAtParCoupons(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withAtParCoupons__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeVanillaSwap *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_withAtParCoupons" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      result = (MakeVanillaSwap *) &(arg1)->withAtParCoupons();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_withAtParCoupons(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeVanillaSwap_withAtParCoupons", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeVanillaSwap_withAtParCoupons__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeVanillaSwap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeVanillaSwap_withAtParCoupons__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeVanillaSwap_withAtParCoupons'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeVanillaSwap::withAtParCoupons(bool)\n"
    "    MakeVanillaSwap::withAtParCoupons()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new__MakeVanillaSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< IborIndex > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  MakeVanillaSwap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new__MakeVanillaSwap", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__MakeVanillaSwap" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__MakeVanillaSwap" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__MakeVanillaSwap" "', argument " "2"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new__MakeVanillaSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new__MakeVanillaSwap" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__MakeVanillaSwap" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (MakeVanillaSwap *)new MakeVanillaSwap((Period const &)*arg1,(ext::shared_ptr< IborIndex > const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeVanillaSwap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeVanillaSwap_makeVanillaSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< VanillaSwap > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeVanillaSwap_makeVanillaSwap" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      result = MakeVanillaSwap_makeVanillaSwap(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwap > *smartresult = result ? new ext::shared_ptr<  VanillaSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__MakeVanillaSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeVanillaSwap *arg1 = (MakeVanillaSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeVanillaSwap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__MakeVanillaSwap" "', argument " "1"" of type '" "MakeVanillaSwap *""'"); 
  }
  arg1 = reinterpret_cast< MakeVanillaSwap * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_MakeVanillaSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MakeVanillaSwap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_MakeVanillaSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NonstandardSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg9 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  bool arg13 ;
  BusinessDayConvention arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  NonstandardSwap *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NonstandardSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_NonstandardSwap" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg10 = ptr;
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NonstandardSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NonstandardSwap" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_NonstandardSwap" "', argument " "14"" of type '" "BusinessDayConvention""'");
  } 
  arg14 = static_cast< BusinessDayConvention >(val14);
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real,std::allocator< Real > > const &)*arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwap > *smartresult = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg9 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  bool arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  NonstandardSwap *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NonstandardSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_NonstandardSwap" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg10 = ptr;
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NonstandardSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_NonstandardSwap" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real,std::allocator< Real > > const &)*arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwap > *smartresult = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg9 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  NonstandardSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NonstandardSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_NonstandardSwap" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg10 = ptr;
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_NonstandardSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real,std::allocator< Real > > const &)*arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwap > *smartresult = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg9 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  NonstandardSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NonstandardSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_NonstandardSwap" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg10 = ptr;
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NonstandardSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  {
    try {
      result = (NonstandardSwap *)new NonstandardSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,(std::vector< Real,std::allocator< Real > > const &)*arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10,(DayCounter const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwap > *smartresult = result ? new ext::shared_ptr<  NonstandardSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[15] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NonstandardSwap", 0, 14, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_NonstandardSwap__SWIG_3(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_NonstandardSwap__SWIG_2(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_NonstandardSwap__SWIG_1(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_NonstandardSwap__SWIG_0(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NonstandardSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NonstandardSwap::NonstandardSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Schedule const &,ext::shared_ptr< IborIndex > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,bool const,bool const,BusinessDayConvention)\n"
    "    NonstandardSwap::NonstandardSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Schedule const &,ext::shared_ptr< IborIndex > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,bool const,bool const)\n"
    "    NonstandardSwap::NonstandardSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Schedule const &,ext::shared_ptr< IborIndex > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,bool const)\n"
    "    NonstandardSwap::NonstandardSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Schedule const &,ext::shared_ptr< IborIndex > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_type" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)((NonstandardSwap const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_fixedNominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_fixedNominal" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((NonstandardSwap const *)arg1)->fixedNominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_floatingNominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_floatingNominal" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((NonstandardSwap const *)arg1)->floatingNominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_fixedSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Schedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_fixedSchedule" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Schedule *) &((NonstandardSwap const *)arg1)->fixedSchedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_fixedRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_fixedRate" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((NonstandardSwap const *)arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_fixedDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_fixedDayCount" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &((NonstandardSwap const *)arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_floatingSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Schedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_floatingSchedule" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Schedule *) &((NonstandardSwap const *)arg1)->floatingSchedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_iborIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< IborIndex > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_iborIndex" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< IborIndex > *) &((NonstandardSwap const *)arg1)->iborIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = *result ? new ext::shared_ptr<  IborIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_spread" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)((NonstandardSwap const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_gearing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_gearing" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((NonstandardSwap const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_spreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Spread,std::allocator< Spread > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_spreads" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Spread,std::allocator< Spread > > *) &((NonstandardSwap const *)arg1)->spreads();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_gearings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_gearings" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((NonstandardSwap const *)arg1)->gearings();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_floatingDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_floatingDayCount" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &((NonstandardSwap const *)arg1)->floatingDayCount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_paymentConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_paymentConvention" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)((NonstandardSwap const *)arg1)->paymentConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_fixedLeg" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((NonstandardSwap const *)arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwap_floatingLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap const > tempshared1 ;
  ext::shared_ptr< NonstandardSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwap_floatingLeg" "', argument " "1"" of type '" "NonstandardSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((NonstandardSwap const *)arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NonstandardSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwap *arg1 = (NonstandardSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap > tempshared1 ;
  ext::shared_ptr< NonstandardSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonstandardSwap" "', argument " "1"" of type '" "NonstandardSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NonstandardSwap > * >(argp1);
      arg1 = const_cast< NonstandardSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NonstandardSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NonstandardSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscountingSwapEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DiscountingSwapEngine" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (DiscountingSwapEngine *)new DiscountingSwapEngine((Handle< YieldTermStructure > const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingSwapEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscountingSwapEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (DiscountingSwapEngine *)new DiscountingSwapEngine((Handle< YieldTermStructure > const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingSwapEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (DiscountingSwapEngine *)new DiscountingSwapEngine((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingSwapEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscountingSwapEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (DiscountingSwapEngine *)new_DiscountingSwapEngine__SWIG_3((Handle< YieldTermStructure > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingSwapEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (DiscountingSwapEngine *)new_DiscountingSwapEngine__SWIG_3((Handle< YieldTermStructure > const &)*arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingSwapEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  DiscountingSwapEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingSwapEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (DiscountingSwapEngine *)new_DiscountingSwapEngine__SWIG_3((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingSwapEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingSwapEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountingSwapEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiscountingSwapEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscountingSwapEngine__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DiscountingSwapEngine__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DiscountingSwapEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_DiscountingSwapEngine__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_DiscountingSwapEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_DiscountingSwapEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiscountingSwapEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DiscountingSwapEngine::DiscountingSwapEngine(Handle< YieldTermStructure > const &,bool,Date const &,Date const &)\n"
    "    DiscountingSwapEngine::DiscountingSwapEngine(Handle< YieldTermStructure > const &,bool,Date const &)\n"
    "    DiscountingSwapEngine::DiscountingSwapEngine(Handle< YieldTermStructure > const &,bool)\n"
    "    DiscountingSwapEngine::DiscountingSwapEngine(Handle< YieldTermStructure > const &,Date const &,Date const &)\n"
    "    DiscountingSwapEngine::DiscountingSwapEngine(Handle< YieldTermStructure > const &,Date const &)\n"
    "    DiscountingSwapEngine::DiscountingSwapEngine(Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscountingSwapEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DiscountingSwapEngine *arg1 = (DiscountingSwapEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DiscountingSwapEngine > tempshared1 ;
  ext::shared_ptr< DiscountingSwapEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscountingSwapEngine" "', argument " "1"" of type '" "DiscountingSwapEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DiscountingSwapEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DiscountingSwapEngine > * >(argp1);
      arg1 = const_cast< DiscountingSwapEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DiscountingSwapEngine > * >(argp1);
      arg1 = const_cast< DiscountingSwapEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscountingSwapEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DiscountingSwapEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiscountingSwapEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AssetSwap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  bool arg1 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  Real arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Spread arg5 ;
  Schedule const &arg6_defvalue = Schedule() ;
  Schedule *arg6 = (Schedule *) &arg6_defvalue ;
  DayCounter const &arg7_defvalue = DayCounter() ;
  DayCounter *arg7 = (DayCounter *) &arg7_defvalue ;
  bool arg8 = (bool) true ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"payFixedRate",  (char *)"bond",  (char *)"bondCleanPrice",  (char *)"index",  (char *)"spread",  (char *)"floatSchedule",  (char *)"floatingDayCount",  (char *)"parAssetSwap",  NULL 
  };
  AssetSwap *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOO:new_AssetSwap", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AssetSwap" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AssetSwap" "', argument " "2"" of type '" "ext::shared_ptr< Bond > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AssetSwap" "', argument " "2"" of type '" "ext::shared_ptr< Bond > const &""'"); 
  }
  arg2 = reinterpret_cast< ext::shared_ptr< Bond > * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AssetSwap" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AssetSwap" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_AssetSwap" "', argument " "5"" of type '" "Spread""'");
  } 
  arg5 = static_cast< Spread >(val5);
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_AssetSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
    }
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AssetSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
    }
    arg6 = reinterpret_cast< Schedule * >(argp6);
  }
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_AssetSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AssetSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
    }
    arg7 = reinterpret_cast< DayCounter * >(argp7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_bool(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_AssetSwap" "', argument " "8"" of type '" "bool""'");
    } 
    arg8 = static_cast< bool >(val8);
  }
  {
    try {
      result = (AssetSwap *)new AssetSwap(arg1,(ext::shared_ptr< Bond > const &)*arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5,(Schedule const &)*arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AssetSwap > *smartresult = result ? new ext::shared_ptr<  AssetSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AssetSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AssetSwap_fairCleanPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AssetSwap *arg1 = (AssetSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AssetSwap > tempshared1 ;
  ext::shared_ptr< AssetSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AssetSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AssetSwap_fairCleanPrice" "', argument " "1"" of type '" "AssetSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      arg1 = const_cast< AssetSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      arg1 = const_cast< AssetSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fairCleanPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AssetSwap_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AssetSwap *arg1 = (AssetSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AssetSwap > tempshared1 ;
  ext::shared_ptr< AssetSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AssetSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AssetSwap_fairSpread" "', argument " "1"" of type '" "AssetSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      arg1 = const_cast< AssetSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      arg1 = const_cast< AssetSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AssetSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AssetSwap *arg1 = (AssetSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AssetSwap > tempshared1 ;
  ext::shared_ptr< AssetSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AssetSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AssetSwap" "', argument " "1"" of type '" "AssetSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      arg1 = const_cast< AssetSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AssetSwap > * >(argp1);
      arg1 = const_cast< AssetSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AssetSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AssetSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AssetSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg16 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg17 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg18 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg19 = 0 ;
  BusinessDayConvention arg20 ;
  BusinessDayConvention arg21 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  int res16 = SWIG_OLDOBJ ;
  int res17 = SWIG_OLDOBJ ;
  int res18 = SWIG_OLDOBJ ;
  int res19 = SWIG_OLDOBJ ;
  int val20 ;
  int ecode20 = 0 ;
  int val21 ;
  int ecode21 = 0 ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 21) || (nobjs > 21)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res16 = swig::asptr(swig_obj[15], &ptr);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg16 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res17 = swig::asptr(swig_obj[16], &ptr);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg17 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res18 = swig::asptr(swig_obj[17], &ptr);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg18 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res19 = swig::asptr(swig_obj[18], &ptr);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_FloatFloatSwap" "', argument " "19"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "19"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg19 = ptr;
  }
  ecode20 = SWIG_AsVal_int(swig_obj[19], &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "new_FloatFloatSwap" "', argument " "20"" of type '" "BusinessDayConvention""'");
  } 
  arg20 = static_cast< BusinessDayConvention >(val20);
  ecode21 = SWIG_AsVal_int(swig_obj[20], &val21);
  if (!SWIG_IsOK(ecode21)) {
    SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "new_FloatFloatSwap" "', argument " "21"" of type '" "BusinessDayConvention""'");
  } 
  arg21 = static_cast< BusinessDayConvention >(val21);
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15,(std::vector< Real,std::allocator< Real > > const &)*arg16,(std::vector< Real,std::allocator< Real > > const &)*arg17,(std::vector< Real,std::allocator< Real > > const &)*arg18,(std::vector< Real,std::allocator< Real > > const &)*arg19,arg20,arg21);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  if (SWIG_IsNewObj(res19)) delete arg19;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  if (SWIG_IsNewObj(res19)) delete arg19;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg16 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg17 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg18 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg19 = 0 ;
  BusinessDayConvention arg20 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  int res16 = SWIG_OLDOBJ ;
  int res17 = SWIG_OLDOBJ ;
  int res18 = SWIG_OLDOBJ ;
  int res19 = SWIG_OLDOBJ ;
  int val20 ;
  int ecode20 = 0 ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 20) || (nobjs > 20)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res16 = swig::asptr(swig_obj[15], &ptr);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg16 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res17 = swig::asptr(swig_obj[16], &ptr);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg17 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res18 = swig::asptr(swig_obj[17], &ptr);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg18 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res19 = swig::asptr(swig_obj[18], &ptr);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_FloatFloatSwap" "', argument " "19"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "19"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg19 = ptr;
  }
  ecode20 = SWIG_AsVal_int(swig_obj[19], &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "new_FloatFloatSwap" "', argument " "20"" of type '" "BusinessDayConvention""'");
  } 
  arg20 = static_cast< BusinessDayConvention >(val20);
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15,(std::vector< Real,std::allocator< Real > > const &)*arg16,(std::vector< Real,std::allocator< Real > > const &)*arg17,(std::vector< Real,std::allocator< Real > > const &)*arg18,(std::vector< Real,std::allocator< Real > > const &)*arg19,arg20);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  if (SWIG_IsNewObj(res19)) delete arg19;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  if (SWIG_IsNewObj(res19)) delete arg19;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg16 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg17 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg18 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg19 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  int res16 = SWIG_OLDOBJ ;
  int res17 = SWIG_OLDOBJ ;
  int res18 = SWIG_OLDOBJ ;
  int res19 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 19) || (nobjs > 19)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res16 = swig::asptr(swig_obj[15], &ptr);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg16 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res17 = swig::asptr(swig_obj[16], &ptr);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg17 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res18 = swig::asptr(swig_obj[17], &ptr);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg18 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res19 = swig::asptr(swig_obj[18], &ptr);
    if (!SWIG_IsOK(res19)) {
      SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "new_FloatFloatSwap" "', argument " "19"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "19"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg19 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15,(std::vector< Real,std::allocator< Real > > const &)*arg16,(std::vector< Real,std::allocator< Real > > const &)*arg17,(std::vector< Real,std::allocator< Real > > const &)*arg18,(std::vector< Real,std::allocator< Real > > const &)*arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  if (SWIG_IsNewObj(res19)) delete arg19;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  if (SWIG_IsNewObj(res19)) delete arg19;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg16 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg17 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg18 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  int res16 = SWIG_OLDOBJ ;
  int res17 = SWIG_OLDOBJ ;
  int res18 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res16 = swig::asptr(swig_obj[15], &ptr);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg16 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res17 = swig::asptr(swig_obj[16], &ptr);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg17 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res18 = swig::asptr(swig_obj[17], &ptr);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg18 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15,(std::vector< Real,std::allocator< Real > > const &)*arg16,(std::vector< Real,std::allocator< Real > > const &)*arg17,(std::vector< Real,std::allocator< Real > > const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  if (SWIG_IsNewObj(res18)) delete arg18;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg16 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg17 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  int res16 = SWIG_OLDOBJ ;
  int res17 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res16 = swig::asptr(swig_obj[15], &ptr);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg16 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res17 = swig::asptr(swig_obj[16], &ptr);
    if (!SWIG_IsOK(res17)) {
      SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "17"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg17 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15,(std::vector< Real,std::allocator< Real > > const &)*arg16,(std::vector< Real,std::allocator< Real > > const &)*arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  if (SWIG_IsNewObj(res17)) delete arg17;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg16 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  int res16 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res16 = swig::asptr(swig_obj[15], &ptr);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "16"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg16 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15,(std::vector< Real,std::allocator< Real > > const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  if (SWIG_IsNewObj(res16)) delete arg16;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg15 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  int res15 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res15 = swig::asptr(swig_obj[14], &ptr);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "15"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg15 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14,(std::vector< Real,std::allocator< Real > > const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  if (SWIG_IsNewObj(res15)) delete arg15;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg14 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  int res14 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res14 = swig::asptr(swig_obj[13], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "14"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg14 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13,(std::vector< Real,std::allocator< Real > > const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  if (SWIG_IsNewObj(res14)) delete arg14;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg13 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int res13 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res13 = swig::asptr(swig_obj[12], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "13"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg13 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,(std::vector< Real,std::allocator< Real > > const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  if (SWIG_IsNewObj(res13)) delete arg13;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  std::vector< Real,std::allocator< Real > > *arg12 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res12 = swig::asptr(swig_obj[11], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg12 = ptr;
  }
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatFloatSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  bool arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_FloatFloatSwap" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Schedule *arg4 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< InterestRateIndex > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  FloatFloatSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatFloatSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatFloatSwap" "', argument " "5"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatFloatSwap" "', argument " "8"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatFloatSwap" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  {
    try {
      result = (FloatFloatSwap *)new FloatFloatSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(std::vector< Real,std::allocator< Real > > const &)*arg3,(Schedule const &)*arg4,(ext::shared_ptr< InterestRateIndex > const &)*arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< InterestRateIndex > const &)*arg8,(DayCounter const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[22] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FloatFloatSwap", 0, 21, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_FloatFloatSwap__SWIG_12(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_FloatFloatSwap__SWIG_11(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_FloatFloatSwap__SWIG_10(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_FloatFloatSwap__SWIG_9(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_FloatFloatSwap__SWIG_8(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_FloatFloatSwap__SWIG_7(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_FloatFloatSwap__SWIG_6(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = swig::asptr(argv[15], (std::vector< double,std::allocator< double > >**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_FloatFloatSwap__SWIG_5(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = swig::asptr(argv[15], (std::vector< double,std::allocator< double > >**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = swig::asptr(argv[16], (std::vector< double,std::allocator< double > >**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_new_FloatFloatSwap__SWIG_4(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = swig::asptr(argv[15], (std::vector< double,std::allocator< double > >**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = swig::asptr(argv[16], (std::vector< double,std::allocator< double > >**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = swig::asptr(argv[17], (std::vector< double,std::allocator< double > >**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        return _wrap_new_FloatFloatSwap__SWIG_3(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = swig::asptr(argv[15], (std::vector< double,std::allocator< double > >**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = swig::asptr(argv[16], (std::vector< double,std::allocator< double > >**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = swig::asptr(argv[17], (std::vector< double,std::allocator< double > >**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = swig::asptr(argv[18], (std::vector< double,std::allocator< double > >**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          return _wrap_new_FloatFloatSwap__SWIG_2(self, argc, argv);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = swig::asptr(argv[15], (std::vector< double,std::allocator< double > >**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = swig::asptr(argv[16], (std::vector< double,std::allocator< double > >**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = swig::asptr(argv[17], (std::vector< double,std::allocator< double > >**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = swig::asptr(argv[18], (std::vector< double,std::allocator< double > >**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_new_FloatFloatSwap__SWIG_1(self, argc, argv);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 21) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = swig::asptr(argv[11], (std::vector< double,std::allocator< double > >**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = swig::asptr(argv[12], (std::vector< double,std::allocator< double > >**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = swig::asptr(argv[13], (std::vector< double,std::allocator< double > >**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = swig::asptr(argv[14], (std::vector< double,std::allocator< double > >**)(0));
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = swig::asptr(argv[15], (std::vector< double,std::allocator< double > >**)(0));
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    int res = swig::asptr(argv[16], (std::vector< double,std::allocator< double > >**)(0));
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      int res = swig::asptr(argv[17], (std::vector< double,std::allocator< double > >**)(0));
                                      _v = SWIG_CheckState(res);
                                      if (_v) {
                                        int res = swig::asptr(argv[18], (std::vector< double,std::allocator< double > >**)(0));
                                        _v = SWIG_CheckState(res);
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            {
                                              int res = SWIG_AsVal_int(argv[20], NULL);
                                              _v = SWIG_CheckState(res);
                                            }
                                            if (_v) {
                                              return _wrap_new_FloatFloatSwap__SWIG_0(self, argc, argv);
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FloatFloatSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,BusinessDayConvention,BusinessDayConvention)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,BusinessDayConvention)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const,std::vector< Real,std::allocator< Real > > const &)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const,bool const)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,bool const)\n"
    "    FloatFloatSwap::FloatFloatSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &,Schedule const &,ext::shared_ptr< InterestRateIndex > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FloatFloatSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatFloatSwap *arg1 = (FloatFloatSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwap > tempshared1 ;
  ext::shared_ptr< FloatFloatSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatFloatSwap" "', argument " "1"" of type '" "FloatFloatSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatFloatSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatFloatSwap > * >(argp1);
      arg1 = const_cast< FloatFloatSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatFloatSwap > * >(argp1);
      arg1 = const_cast< FloatFloatSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloatFloatSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FloatFloatSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  RateAveraging::Type arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "RateAveraging::Type""'");
  } 
  arg12 = static_cast< RateAveraging::Type >(val12);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  RateAveraging::Type arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "RateAveraging::Type""'");
  } 
  arg12 = static_cast< RateAveraging::Type >(val12);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  bool arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  SwigValueWrapper< Calendar > arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  BusinessDayConvention arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  Integer arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "Integer""'");
  } 
  arg8 = static_cast< Integer >(val8);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  Spread arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  double val7 ;
  int ecode7 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Spread""'");
  } 
  arg7 = static_cast< Spread >(val7);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared6 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(ext::shared_ptr< OvernightIndex > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  Calendar *arg12 = 0 ;
  bool arg13 ;
  RateAveraging::Type arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Integer""'");
  } 
  arg10 = static_cast< Integer >(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "BusinessDayConvention""'");
  } 
  arg11 = static_cast< BusinessDayConvention >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_OvernightIndexedSwap" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_OvernightIndexedSwap" "', argument " "14"" of type '" "RateAveraging::Type""'");
  } 
  arg14 = static_cast< RateAveraging::Type >(val14);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,arg11,(Calendar const &)*arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  Calendar *arg12 = 0 ;
  bool arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Integer""'");
  } 
  arg10 = static_cast< Integer >(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "BusinessDayConvention""'");
  } 
  arg11 = static_cast< BusinessDayConvention >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_OvernightIndexedSwap" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,arg11,(Calendar const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  Calendar *arg12 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Integer""'");
  } 
  arg10 = static_cast< Integer >(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "BusinessDayConvention""'");
  } 
  arg11 = static_cast< BusinessDayConvention >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,arg11,(Calendar const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  BusinessDayConvention arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Integer""'");
  } 
  arg10 = static_cast< Integer >(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_OvernightIndexedSwap" "', argument " "11"" of type '" "BusinessDayConvention""'");
  } 
  arg11 = static_cast< BusinessDayConvention >(val11);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  Integer arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_OvernightIndexedSwap" "', argument " "10"" of type '" "Integer""'");
  } 
  arg10 = static_cast< Integer >(val10);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  Spread arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OvernightIndexedSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared8 ;
  OvernightIndexedSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OvernightIndexedSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OvernightIndexedSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwap" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIndexedSwap" "', argument " "8"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (OvernightIndexedSwap *)new OvernightIndexedSwap(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(Schedule const &)*arg7,(ext::shared_ptr< OvernightIndex > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[15] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexedSwap", 0, 14, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_OvernightIndexedSwap__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_OvernightIndexedSwap__SWIG_13(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_OvernightIndexedSwap__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_OvernightIndexedSwap__SWIG_12(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_OvernightIndexedSwap__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_OvernightIndexedSwap__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_OvernightIndexedSwap__SWIG_20(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_OvernightIndexedSwap__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_OvernightIndexedSwap__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_OvernightIndexedSwap__SWIG_19(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_OvernightIndexedSwap__SWIG_2(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_OvernightIndexedSwap__SWIG_9(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_OvernightIndexedSwap__SWIG_18(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_OvernightIndexedSwap__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_OvernightIndexedSwap__SWIG_8(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_OvernightIndexedSwap__SWIG_17(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_OvernightIndexedSwap__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_OvernightIndexedSwap__SWIG_7(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_OvernightIndexedSwap__SWIG_16(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_OvernightIndexedSwap__SWIG_15(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_OvernightIndexedSwap__SWIG_14(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIndexedSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar,bool,RateAveraging::Type)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar,bool)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar,bool,RateAveraging::Type)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar,bool)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &,Spread)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter const &,ext::shared_ptr< OvernightIndex > const &)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar const &,bool,RateAveraging::Type)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar const &,bool)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention,Calendar const &)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer,BusinessDayConvention)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &,Spread,Integer)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &,Spread)\n"
    "    OvernightIndexedSwap::OvernightIndexedSwap(Swap::Type,std::vector< Real,std::allocator< Real > > const &,Schedule const &,Rate,DayCounter const &,std::vector< Real,std::allocator< Real > > const &,Schedule const &,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fixedLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fixedLegBPS" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fixedLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fixedLegNPV" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fairRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fairRate" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_overnightLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_overnightLegBPS" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->overnightLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_overnightLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_overnightLegNPV" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->overnightLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fairSpread" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_type" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)(arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_nominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_nominal" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->nominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_nominals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_nominals" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->nominals();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_paymentFrequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_paymentFrequency" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)(arg1)->paymentFrequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fixedRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fixedRate" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fixedDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fixedDayCount" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &(arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_overnightIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_overnightIndex" "', argument " "1"" of type '" "OvernightIndexedSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((OvernightIndexedSwap const *)arg1)->overnightIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_spread" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_fixedLeg" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_overnightLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_overnightLeg" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->overnightLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwap_averagingMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  RateAveraging::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwap_averagingMethod" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (RateAveraging::Type)(arg1)->averagingMethod();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIndexedSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwap *arg1 = (OvernightIndexedSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwap > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndexedSwap" "', argument " "1"" of type '" "OvernightIndexedSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwap > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIndexedSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIndexedSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new__MakeOIS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg2 = 0 ;
  Rate arg3 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__MakeOIS" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__MakeOIS" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__MakeOIS" "', argument " "2"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new__MakeOIS" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new__MakeOIS" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__MakeOIS" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (MakeOIS *)new MakeOIS((Period const &)*arg1,(ext::shared_ptr< OvernightIndex > const &)*arg2,arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__MakeOIS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__MakeOIS" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__MakeOIS" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__MakeOIS" "', argument " "2"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new__MakeOIS" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (MakeOIS *)new MakeOIS((Period const &)*arg1,(ext::shared_ptr< OvernightIndex > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__MakeOIS__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared2 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new__MakeOIS" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new__MakeOIS" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new__MakeOIS" "', argument " "2"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (MakeOIS *)new MakeOIS((Period const &)*arg1,(ext::shared_ptr< OvernightIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new__MakeOIS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new__MakeOIS", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new__MakeOIS__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new__MakeOIS__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new__MakeOIS__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new__MakeOIS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeOIS::MakeOIS(Period const &,ext::shared_ptr< OvernightIndex > const &,Rate,Period const &)\n"
    "    MakeOIS::MakeOIS(Period const &,ext::shared_ptr< OvernightIndex > const &,Rate)\n"
    "    MakeOIS::MakeOIS(Period const &,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeOIS_makeOIS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_makeOIS" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  {
    try {
      result = MakeOIS_makeOIS(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_receiveFixed__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_receiveFixed" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_receiveFixed" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->receiveFixed(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_receiveFixed__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_receiveFixed" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  {
    try {
      result = (MakeOIS *) &(arg1)->receiveFixed();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_receiveFixed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeOIS_receiveFixed", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeOIS, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeOIS_receiveFixed__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeOIS, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeOIS_receiveFixed__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeOIS_receiveFixed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeOIS::receiveFixed(bool)\n"
    "    MakeOIS::receiveFixed()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Swap::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withType", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withType" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withType" "', argument " "2"" of type '" "Swap::Type""'");
  } 
  arg2 = static_cast< Swap::Type >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withType(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withNominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withNominal", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withNominal" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withNominal" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withNominal(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withSettlementDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Natural arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withSettlementDays", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withSettlementDays" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withSettlementDays" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withSettlementDays(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withEffectiveDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withEffectiveDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withEffectiveDate" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeOIS_withEffectiveDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeOIS_withEffectiveDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withEffectiveDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withTerminationDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withTerminationDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withTerminationDate" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeOIS_withTerminationDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeOIS_withTerminationDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withTerminationDate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withRule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  DateGeneration::Rule arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withRule", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withRule" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withRule" "', argument " "2"" of type '" "DateGeneration::Rule""'");
  } 
  arg2 = static_cast< DateGeneration::Rule >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withRule(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withPaymentFrequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Frequency arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withPaymentFrequency", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withPaymentFrequency" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withPaymentFrequency" "', argument " "2"" of type '" "Frequency""'");
  } 
  arg2 = static_cast< Frequency >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withPaymentFrequency(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withPaymentAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  BusinessDayConvention arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withPaymentAdjustment", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withPaymentAdjustment" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withPaymentAdjustment" "', argument " "2"" of type '" "BusinessDayConvention""'");
  } 
  arg2 = static_cast< BusinessDayConvention >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withPaymentAdjustment(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withPaymentLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withPaymentLag", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withPaymentLag" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withPaymentLag" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withPaymentLag(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withPaymentCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Calendar *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withPaymentCalendar", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withPaymentCalendar" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeOIS_withPaymentCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeOIS_withPaymentCalendar" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withPaymentCalendar((Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withEndOfMonth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withEndOfMonth" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withEndOfMonth" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withEndOfMonth(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withEndOfMonth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  MakeOIS *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withEndOfMonth" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  {
    try {
      result = (MakeOIS *) &(arg1)->withEndOfMonth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withEndOfMonth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "_MakeOIS_withEndOfMonth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeOIS, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap__MakeOIS_withEndOfMonth__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_MakeOIS, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap__MakeOIS_withEndOfMonth__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function '_MakeOIS_withEndOfMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MakeOIS::withEndOfMonth(bool)\n"
    "    MakeOIS::withEndOfMonth()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withFixedLegDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  DayCounter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withFixedLegDayCount", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withFixedLegDayCount" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeOIS_withFixedLegDayCount" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeOIS_withFixedLegDayCount" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withFixedLegDayCount((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withOvernightLegSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Spread arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withOvernightLegSpread", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withOvernightLegSpread" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withOvernightLegSpread" "', argument " "2"" of type '" "Spread""'");
  } 
  arg2 = static_cast< Spread >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withOvernightLegSpread(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withDiscountingTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withDiscountingTermStructure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withDiscountingTermStructure" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeOIS_withDiscountingTermStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_MakeOIS_withDiscountingTermStructure" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withDiscountingTermStructure((Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withTelescopicValueDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withTelescopicValueDates", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withTelescopicValueDates" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withTelescopicValueDates" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withTelescopicValueDates(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withAveragingMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  RateAveraging::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withAveragingMethod", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withAveragingMethod" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_MakeOIS_withAveragingMethod" "', argument " "2"" of type '" "RateAveraging::Type""'");
  } 
  arg2 = static_cast< RateAveraging::Type >(val2);
  {
    try {
      result = (MakeOIS *) &(arg1)->withAveragingMethod(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap__MakeOIS_withPricingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared2 ;
  PyObject *swig_obj[2] ;
  MakeOIS *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "_MakeOIS_withPricingEngine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_MakeOIS_withPricingEngine" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_MakeOIS_withPricingEngine" "', argument " "2"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (MakeOIS *) &(arg1)->withPricingEngine((ext::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MakeOIS, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete__MakeOIS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MakeOIS *arg1 = (MakeOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MakeOIS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__MakeOIS" "', argument " "1"" of type '" "MakeOIS *""'"); 
  }
  arg1 = reinterpret_cast< MakeOIS * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_MakeOIS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MakeOIS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_MakeOIS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwapIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  bool arg6 ;
  RateAveraging::Type arg7 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  OvernightIndexedSwapIndex *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "4"" of type '" "Currency""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "4"" of type '" "Currency""'");
    } else {
      Currency * temp = reinterpret_cast< Currency * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "7"" of type '" "RateAveraging::Type""'");
  } 
  arg7 = static_cast< RateAveraging::Type >(val7);
  {
    try {
      result = (OvernightIndexedSwapIndex *)new OvernightIndexedSwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwapIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwapIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwapIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  bool val6 ;
  int ecode6 = 0 ;
  OvernightIndexedSwapIndex *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "4"" of type '" "Currency""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "4"" of type '" "Currency""'");
    } else {
      Currency * temp = reinterpret_cast< Currency * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (OvernightIndexedSwapIndex *)new OvernightIndexedSwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwapIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwapIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwapIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Currency arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  OvernightIndexedSwapIndex *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Currency,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "4"" of type '" "Currency""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexedSwapIndex" "', argument " "4"" of type '" "Currency""'");
    } else {
      Currency * temp = reinterpret_cast< Currency * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexedSwapIndex" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (OvernightIndexedSwapIndex *)new OvernightIndexedSwapIndex((std::string const &)*arg1,(Period const &)*arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwapIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwapIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexedSwapIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexedSwapIndex", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_OvernightIndexedSwapIndex__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_OvernightIndexedSwapIndex__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_OvernightIndexedSwapIndex__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIndexedSwapIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIndexedSwapIndex::OvernightIndexedSwapIndex(std::string const &,Period const &,Natural,Currency,ext::shared_ptr< OvernightIndex > const &,bool,RateAveraging::Type)\n"
    "    OvernightIndexedSwapIndex::OvernightIndexedSwapIndex(std::string const &,Period const &,Natural,Currency,ext::shared_ptr< OvernightIndex > const &,bool)\n"
    "    OvernightIndexedSwapIndex::OvernightIndexedSwapIndex(std::string const &,Period const &,Natural,Currency,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwapIndex_overnightIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwapIndex *arg1 = (OvernightIndexedSwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwapIndex const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwapIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwapIndex_overnightIndex" "', argument " "1"" of type '" "OvernightIndexedSwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwapIndex > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwapIndex > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((OvernightIndexedSwapIndex const *)arg1)->overnightIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OvernightIndexedSwapIndex_underlyingSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwapIndex *arg1 = (OvernightIndexedSwapIndex *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwapIndex const > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwapIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  if (!SWIG_Python_UnpackTuple(args, "OvernightIndexedSwapIndex_underlyingSwap", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexedSwapIndex_underlyingSwap" "', argument " "1"" of type '" "OvernightIndexedSwapIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwapIndex > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexedSwapIndex > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OvernightIndexedSwapIndex_underlyingSwap" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OvernightIndexedSwapIndex_underlyingSwap" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((OvernightIndexedSwapIndex const *)arg1)->underlyingSwap((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIndexedSwapIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexedSwapIndex *arg1 = (OvernightIndexedSwapIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexedSwapIndex > tempshared1 ;
  ext::shared_ptr< OvernightIndexedSwapIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndexedSwapIndex" "', argument " "1"" of type '" "OvernightIndexedSwapIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwapIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwapIndex > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwapIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexedSwapIndex > * >(argp1);
      arg1 = const_cast< OvernightIndexedSwapIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIndexedSwapIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwapIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIndexedSwapIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_overnight_swap_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< InterestRateIndex > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< InterestRateIndex > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_overnight_swap_index" "', argument " "1"" of type '" "ext::shared_ptr< InterestRateIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< InterestRateIndex > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_overnight_swap_index((ext::shared_ptr< InterestRateIndex > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > arg6 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  Natural arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  unsigned int val9 ;
  int ecode9 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponSwap" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  ecode9 = SWIG_AsVal_unsigned_SS_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZeroCouponSwap" "', argument " "9"" of type '" "Natural""'");
  } 
  arg9 = static_cast< Natural >(val9);
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,arg6,(Calendar const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > arg6 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponSwap" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,arg6,(Calendar const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > arg6 ;
  Calendar *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponSwap" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,arg6,(Calendar const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Rate arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > arg7 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  Natural arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 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 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  unsigned int val10 ;
  int ecode10 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponSwap" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp7) arg7 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZeroCouponSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ZeroCouponSwap" "', argument " "10"" of type '" "Natural""'");
  } 
  arg10 = static_cast< Natural >(val10);
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,(Calendar const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Rate arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > arg7 ;
  Calendar *arg8 = 0 ;
  BusinessDayConvention arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 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 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponSwap" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp7) arg7 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ZeroCouponSwap" "', argument " "9"" of type '" "BusinessDayConvention""'");
  } 
  arg9 = static_cast< BusinessDayConvention >(val9);
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,(Calendar const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Rate arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > arg7 ;
  Calendar *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 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 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  ZeroCouponSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponSwap" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponSwap" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp7) arg7 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponSwap" "', argument " "8"" of type '" "Calendar const &""'"); 
  }
  arg8 = reinterpret_cast< Calendar * >(argp8);
  {
    try {
      result = (ZeroCouponSwap *)new ZeroCouponSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,(Calendar const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroCouponSwap", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ZeroCouponSwap__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ZeroCouponSwap__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_ZeroCouponSwap__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ZeroCouponSwap__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ZeroCouponSwap__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ZeroCouponSwap__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroCouponSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroCouponSwap::ZeroCouponSwap(Swap::Type,Real,Date const &,Date const &,Real,ext::shared_ptr< IborIndex >,Calendar const &,BusinessDayConvention,Natural)\n"
    "    ZeroCouponSwap::ZeroCouponSwap(Swap::Type,Real,Date const &,Date const &,Real,ext::shared_ptr< IborIndex >,Calendar const &,BusinessDayConvention)\n"
    "    ZeroCouponSwap::ZeroCouponSwap(Swap::Type,Real,Date const &,Date const &,Real,ext::shared_ptr< IborIndex >,Calendar const &)\n"
    "    ZeroCouponSwap::ZeroCouponSwap(Swap::Type,Real,Date const &,Date const &,Rate,DayCounter const &,ext::shared_ptr< IborIndex >,Calendar const &,BusinessDayConvention,Natural)\n"
    "    ZeroCouponSwap::ZeroCouponSwap(Swap::Type,Real,Date const &,Date const &,Rate,DayCounter const &,ext::shared_ptr< IborIndex >,Calendar const &,BusinessDayConvention)\n"
    "    ZeroCouponSwap::ZeroCouponSwap(Swap::Type,Real,Date const &,Date const &,Rate,DayCounter const &,ext::shared_ptr< IborIndex >,Calendar const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_type" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)((ZeroCouponSwap const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_baseNominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_baseNominal" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->baseNominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_iborIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< IborIndex > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_iborIndex" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< IborIndex > *) &((ZeroCouponSwap const *)arg1)->iborIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIndex > *smartresult = *result ? new ext::shared_ptr<  IborIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_fixedLeg" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((ZeroCouponSwap const *)arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_floatingLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_floatingLeg" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((ZeroCouponSwap const *)arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_fixedPayment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_fixedPayment" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->fixedPayment();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_fixedLegNPV" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_floatingLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_floatingLegNPV" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->floatingLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_fairFixedPayment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_fairFixedPayment" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZeroCouponSwap const *)arg1)->fairFixedPayment();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponSwap_fairFixedRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  DayCounter *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap const > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroCouponSwap_fairFixedRate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponSwap_fairFixedRate" "', argument " "1"" of type '" "ZeroCouponSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroCouponSwap_fairFixedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroCouponSwap_fairFixedRate" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  {
    try {
      result = (Rate)((ZeroCouponSwap const *)arg1)->fairFixedRate((DayCounter const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroCouponSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponSwap *arg1 = (ZeroCouponSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroCouponSwap" "', argument " "1"" of type '" "ZeroCouponSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroCouponSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroCouponSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroCouponSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  Natural arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_EquityTotalReturnSwap" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_EquityTotalReturnSwap" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_EquityTotalReturnSwap" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  Natural arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_EquityTotalReturnSwap" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_EquityTotalReturnSwap" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  BusinessDayConvention arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_EquityTotalReturnSwap" "', argument " "10"" of type '" "BusinessDayConvention""'");
  } 
  arg10 = static_cast< BusinessDayConvention >(val10);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  SwigValueWrapper< Calendar > arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "9"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  Real arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_EquityTotalReturnSwap" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule arg3 ;
  ext::shared_ptr< EquityIndex > arg4 ;
  ext::shared_ptr< OvernightIndex > *arg5 = 0 ;
  SwigValueWrapper< DayCounter > arg6 ;
  Rate arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared5 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  EquityTotalReturnSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquityTotalReturnSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquityTotalReturnSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "3"" of type '" "Schedule""'");
    } else {
      Schedule * temp = reinterpret_cast< Schedule * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EquityTotalReturnSwap" "', argument " "4"" of type '" "ext::shared_ptr< EquityIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< EquityIndex > * >(argp4);
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EquityTotalReturnSwap" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EquityTotalReturnSwap" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_EquityTotalReturnSwap" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  {
    try {
      result = (EquityTotalReturnSwap *)new EquityTotalReturnSwap(arg1,arg2,arg3,arg4,(ext::shared_ptr< OvernightIndex > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityTotalReturnSwap > *smartresult = result ? new ext::shared_ptr<  EquityTotalReturnSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EquityTotalReturnSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EquityTotalReturnSwap", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_EquityTotalReturnSwap__SWIG_9(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_EquityTotalReturnSwap__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_EquityTotalReturnSwap__SWIG_8(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_EquityTotalReturnSwap__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_EquityTotalReturnSwap__SWIG_7(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_EquityTotalReturnSwap__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_EquityTotalReturnSwap__SWIG_6(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_EquityTotalReturnSwap__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_EquityTotalReturnSwap__SWIG_5(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_EquityTotalReturnSwap__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EquityTotalReturnSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< IborIndex > const &,DayCounter,Rate,Real,Calendar,BusinessDayConvention,Natural)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< IborIndex > const &,DayCounter,Rate,Real,Calendar,BusinessDayConvention)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< IborIndex > const &,DayCounter,Rate,Real,Calendar)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< IborIndex > const &,DayCounter,Rate,Real)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< IborIndex > const &,DayCounter,Rate)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< OvernightIndex > const &,DayCounter,Rate,Real,Calendar,BusinessDayConvention,Natural)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< OvernightIndex > const &,DayCounter,Rate,Real,Calendar,BusinessDayConvention)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< OvernightIndex > const &,DayCounter,Rate,Real,Calendar)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< OvernightIndex > const &,DayCounter,Rate,Real)\n"
    "    EquityTotalReturnSwap::EquityTotalReturnSwap(Swap::Type,Real,Schedule,ext::shared_ptr< EquityIndex >,ext::shared_ptr< OvernightIndex > const &,DayCounter,Rate)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_type" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)((EquityTotalReturnSwap const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_nominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_nominal" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->nominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_equityIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< EquityIndex > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_equityIndex" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< EquityIndex > *) &((EquityTotalReturnSwap const *)arg1)->equityIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EquityIndex > *smartresult = *result ? new ext::shared_ptr<  EquityIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EquityIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_interestRateIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< InterestRateIndex > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_interestRateIndex" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< InterestRateIndex > *) &((EquityTotalReturnSwap const *)arg1)->interestRateIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterestRateIndex > *smartresult = *result ? new ext::shared_ptr<  InterestRateIndex >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterestRateIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_schedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Schedule *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_schedule" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Schedule *) &((EquityTotalReturnSwap const *)arg1)->schedule();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Schedule, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_dayCounter" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &((EquityTotalReturnSwap const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_margin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_margin" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((EquityTotalReturnSwap const *)arg1)->margin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_gearing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_gearing" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_paymentCalendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Calendar *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_paymentCalendar" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Calendar *) &((EquityTotalReturnSwap const *)arg1)->paymentCalendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Calendar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_paymentConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_paymentConvention" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)((EquityTotalReturnSwap const *)arg1)->paymentConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_paymentDelay(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Natural result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_paymentDelay" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Natural)((EquityTotalReturnSwap const *)arg1)->paymentDelay();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_equityLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_equityLeg" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((EquityTotalReturnSwap const *)arg1)->equityLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_interestRateLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_interestRateLeg" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((EquityTotalReturnSwap const *)arg1)->interestRateLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_equityLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_equityLegNPV" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->equityLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_interestRateLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_interestRateLegNPV" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->interestRateLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EquityTotalReturnSwap_fairMargin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap const > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquityTotalReturnSwap_fairMargin" "', argument " "1"" of type '" "EquityTotalReturnSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((EquityTotalReturnSwap const *)arg1)->fairMargin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EquityTotalReturnSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EquityTotalReturnSwap *arg1 = (EquityTotalReturnSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EquityTotalReturnSwap > tempshared1 ;
  ext::shared_ptr< EquityTotalReturnSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquityTotalReturnSwap" "', argument " "1"" of type '" "EquityTotalReturnSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EquityTotalReturnSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EquityTotalReturnSwap > * >(argp1);
      arg1 = const_cast< EquityTotalReturnSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EquityTotalReturnSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EquityTotalReturnSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EquityTotalReturnSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticAverageOIS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ArithmeticAverageOIS" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ArithmeticAverageOIS" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticAverageOIS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ArithmeticAverageOIS" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticAverageOIS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  bool arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticAverageOIS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ArithmeticAverageOIS" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ArithmeticAverageOIS" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  Real arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticAverageOIS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ArithmeticAverageOIS" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  Real arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticAverageOIS" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  Spread arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticAverageOIS" "', argument " "8"" of type '" "Spread""'");
  } 
  arg8 = static_cast< Spread >(val8);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  std::vector< Real,std::allocator< Real > > arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  SwigValueWrapper< DayCounter > arg5 ;
  ext::shared_ptr< OvernightIndex > arg6 ;
  Schedule *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ArithmeticAverageOIS *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticAverageOIS" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ArithmeticAverageOIS" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ArithmeticAverageOIS" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "5"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ArithmeticAverageOIS" "', argument " "6"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp6);
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticAverageOIS" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    try {
      result = (ArithmeticAverageOIS *)new ArithmeticAverageOIS(arg1,arg2,(Schedule const &)*arg3,arg4,arg5,arg6,(Schedule const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticAverageOIS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ArithmeticAverageOIS", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ArithmeticAverageOIS__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ArithmeticAverageOIS__SWIG_9(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ArithmeticAverageOIS__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ArithmeticAverageOIS__SWIG_8(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ArithmeticAverageOIS__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ArithmeticAverageOIS__SWIG_7(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ArithmeticAverageOIS__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ArithmeticAverageOIS__SWIG_6(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ArithmeticAverageOIS__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ArithmeticAverageOIS__SWIG_5(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ArithmeticAverageOIS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,Real,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread,Real,Real,bool)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,Real,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread,Real,Real)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,Real,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread,Real)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,Real,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,Real,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread,Real,Real,bool)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread,Real,Real)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread,Real)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &,Spread)\n"
    "    ArithmeticAverageOIS::ArithmeticAverageOIS(Swap::Type,std::vector< Real,std::allocator< Real > >,Schedule const &,Rate,DayCounter,ext::shared_ptr< OvernightIndex >,Schedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_type" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)((ArithmeticAverageOIS const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_nominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_nominal" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->nominal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_nominals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_nominals" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ArithmeticAverageOIS const *)arg1)->nominals();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fixedLegPaymentFrequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fixedLegPaymentFrequency" "', argument " "1"" of type '" "ArithmeticAverageOIS *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)(arg1)->fixedLegPaymentFrequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_overnightLegPaymentFrequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_overnightLegPaymentFrequency" "', argument " "1"" of type '" "ArithmeticAverageOIS *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)(arg1)->overnightLegPaymentFrequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fixedRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fixedRate" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((ArithmeticAverageOIS const *)arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fixedDayCount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fixedDayCount" "', argument " "1"" of type '" "ArithmeticAverageOIS *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &(arg1)->fixedDayCount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_overnightIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_overnightIndex" "', argument " "1"" of type '" "ArithmeticAverageOIS *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->overnightIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndex > *smartresult = result ? new ext::shared_ptr<  OvernightIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_spread" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)((ArithmeticAverageOIS const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fixedLeg" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((ArithmeticAverageOIS const *)arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_overnightLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_overnightLeg" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((ArithmeticAverageOIS const *)arg1)->overnightLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fixedLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fixedLegBPS" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->fixedLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fixedLegNPV" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fairRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fairRate" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->fairRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_overnightLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_overnightLegBPS" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->overnightLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_overnightLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_overnightLegNPV" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ArithmeticAverageOIS const *)arg1)->overnightLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ArithmeticAverageOIS_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS const > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticAverageOIS_fairSpread" "', argument " "1"" of type '" "ArithmeticAverageOIS const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)((ArithmeticAverageOIS const *)arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ArithmeticAverageOIS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticAverageOIS *arg1 = (ArithmeticAverageOIS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticAverageOIS > tempshared1 ;
  ext::shared_ptr< ArithmeticAverageOIS > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArithmeticAverageOIS" "', argument " "1"" of type '" "ArithmeticAverageOIS *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ArithmeticAverageOIS > * >(argp1);
      arg1 = const_cast< ArithmeticAverageOIS * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ArithmeticAverageOIS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ArithmeticAverageOIS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Seasonality_correctZeroRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Seasonality *arg1 = (Seasonality *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  InflationTermStructure *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Seasonality const > tempshared1 ;
  ext::shared_ptr< Seasonality const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "Seasonality_correctZeroRate", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Seasonality_correctZeroRate" "', argument " "1"" of type '" "Seasonality const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Seasonality > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Seasonality_correctZeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Seasonality_correctZeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Seasonality_correctZeroRate" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_InflationTermStructure,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Seasonality_correctZeroRate" "', argument " "4"" of type '" "InflationTermStructure const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Seasonality_correctZeroRate" "', argument " "4"" of type '" "InflationTermStructure const &""'"); 
  }
  arg4 = reinterpret_cast< InflationTermStructure * >(argp4);
  {
    try {
      result = (Rate)((Seasonality const *)arg1)->correctZeroRate((Date const &)*arg2,arg3,(InflationTermStructure const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Seasonality_correctYoYRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Seasonality *arg1 = (Seasonality *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  InflationTermStructure *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Seasonality const > tempshared1 ;
  ext::shared_ptr< Seasonality const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "Seasonality_correctYoYRate", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Seasonality_correctYoYRate" "', argument " "1"" of type '" "Seasonality const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Seasonality > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Seasonality_correctYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Seasonality_correctYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Seasonality_correctYoYRate" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_InflationTermStructure,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Seasonality_correctYoYRate" "', argument " "4"" of type '" "InflationTermStructure const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Seasonality_correctYoYRate" "', argument " "4"" of type '" "InflationTermStructure const &""'"); 
  }
  arg4 = reinterpret_cast< InflationTermStructure * >(argp4);
  {
    try {
      result = (Rate)((Seasonality const *)arg1)->correctYoYRate((Date const &)*arg2,arg3,(InflationTermStructure const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Seasonality_isConsistent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Seasonality *arg1 = (Seasonality *) 0 ;
  InflationTermStructure *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Seasonality > tempshared1 ;
  ext::shared_ptr< Seasonality > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Seasonality_isConsistent", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Seasonality_isConsistent" "', argument " "1"" of type '" "Seasonality *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Seasonality > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InflationTermStructure,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Seasonality_isConsistent" "', argument " "2"" of type '" "InflationTermStructure const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Seasonality_isConsistent" "', argument " "2"" of type '" "InflationTermStructure const &""'"); 
  }
  arg2 = reinterpret_cast< InflationTermStructure * >(argp2);
  {
    try {
      result = (bool)(arg1)->isConsistent((InflationTermStructure const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Seasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Seasonality *arg1 = (Seasonality *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Seasonality > tempshared1 ;
  ext::shared_ptr< Seasonality > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Seasonality" "', argument " "1"" of type '" "Seasonality *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Seasonality > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Seasonality > * >(argp1);
      arg1 = const_cast< Seasonality * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Seasonality_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MultiplicativePriceSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Frequency arg2 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  MultiplicativePriceSeasonality *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MultiplicativePriceSeasonality", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiplicativePriceSeasonality" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MultiplicativePriceSeasonality" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MultiplicativePriceSeasonality" "', argument " "2"" of type '" "Frequency""'");
  } 
  arg2 = static_cast< Frequency >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MultiplicativePriceSeasonality" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MultiplicativePriceSeasonality" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (MultiplicativePriceSeasonality *)new MultiplicativePriceSeasonality((Date const &)*arg1,arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MultiplicativePriceSeasonality > *smartresult = result ? new ext::shared_ptr<  MultiplicativePriceSeasonality >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MultiplicativePriceSeasonality_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MultiplicativePriceSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiplicativePriceSeasonality *arg1 = (MultiplicativePriceSeasonality *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MultiplicativePriceSeasonality > tempshared1 ;
  ext::shared_ptr< MultiplicativePriceSeasonality > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MultiplicativePriceSeasonality_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiplicativePriceSeasonality" "', argument " "1"" of type '" "MultiplicativePriceSeasonality *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MultiplicativePriceSeasonality > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MultiplicativePriceSeasonality > * >(argp1);
      arg1 = const_cast< MultiplicativePriceSeasonality * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MultiplicativePriceSeasonality > * >(argp1);
      arg1 = const_cast< MultiplicativePriceSeasonality * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultiplicativePriceSeasonality_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MultiplicativePriceSeasonality_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MultiplicativePriceSeasonality_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KerkhofSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  KerkhofSeasonality *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KerkhofSeasonality", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KerkhofSeasonality" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KerkhofSeasonality" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KerkhofSeasonality" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KerkhofSeasonality" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (KerkhofSeasonality *)new KerkhofSeasonality((Date const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KerkhofSeasonality > *smartresult = result ? new ext::shared_ptr<  KerkhofSeasonality >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KerkhofSeasonality_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KerkhofSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KerkhofSeasonality *arg1 = (KerkhofSeasonality *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KerkhofSeasonality > tempshared1 ;
  ext::shared_ptr< KerkhofSeasonality > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KerkhofSeasonality_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KerkhofSeasonality" "', argument " "1"" of type '" "KerkhofSeasonality *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  KerkhofSeasonality > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  KerkhofSeasonality > * >(argp1);
      arg1 = const_cast< KerkhofSeasonality * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  KerkhofSeasonality > * >(argp1);
      arg1 = const_cast< KerkhofSeasonality * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KerkhofSeasonality_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_KerkhofSeasonality_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KerkhofSeasonality_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_InflationTermStructure_observationLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure const > tempshared1 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_observationLag" "', argument " "1"" of type '" "InflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationTermStructure const *)arg1)->observationLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure const > tempshared1 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_frequency" "', argument " "1"" of type '" "InflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)((InflationTermStructure const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_baseRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure const > tempshared1 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_baseRate" "', argument " "1"" of type '" "InflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((InflationTermStructure const *)arg1)->baseRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure const > tempshared1 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_baseDate" "', argument " "1"" of type '" "InflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationTermStructure const *)arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_setSeasonality__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  ext::shared_ptr< Seasonality > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure > tempshared1 ;
  ext::shared_ptr< InflationTermStructure > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Seasonality > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_setSeasonality" "', argument " "1"" of type '" "InflationTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InflationTermStructure_setSeasonality" "', argument " "2"" of type '" "ext::shared_ptr< Seasonality > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setSeasonality((ext::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_setSeasonality__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure > tempshared1 ;
  ext::shared_ptr< InflationTermStructure > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_setSeasonality" "', argument " "1"" of type '" "InflationTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_setSeasonality(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "InflationTermStructure_setSeasonality", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InflationTermStructure_setSeasonality__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InflationTermStructure_setSeasonality__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InflationTermStructure_setSeasonality'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InflationTermStructure::setSeasonality(ext::shared_ptr< Seasonality > const &)\n"
    "    InflationTermStructure::setSeasonality()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_seasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure const > tempshared1 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Seasonality > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_seasonality" "', argument " "1"" of type '" "InflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationTermStructure const *)arg1)->seasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Seasonality > *smartresult = result ? new ext::shared_ptr<  Seasonality >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationTermStructure_hasSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure const > tempshared1 ;
  ext::shared_ptr< InflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationTermStructure_hasSeasonality" "', argument " "1"" of type '" "InflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((InflationTermStructure const *)arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InflationTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationTermStructure *arg1 = (InflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationTermStructure > tempshared1 ;
  ext::shared_ptr< InflationTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InflationTermStructure" "', argument " "1"" of type '" "InflationTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InflationTermStructure > * >(argp1);
      arg1 = const_cast< InflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InflationTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationTermStructure_yoyRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Rate)((YoYInflationTermStructure const *)arg1)->yoyRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_yoyRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYInflationTermStructure_yoyRate", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYInflationTermStructure_yoyRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYInflationTermStructure_yoyRate__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYInflationTermStructure_yoyRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYInflationTermStructure_yoyRate__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YoYInflationTermStructure_yoyRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYInflationTermStructure_yoyRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYInflationTermStructure_yoyRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYInflationTermStructure::yoyRate(Date const &,Period const &,bool,bool) const\n"
    "    YoYInflationTermStructure::yoyRate(Date const &,Period const &,bool) const\n"
    "    YoYInflationTermStructure::yoyRate(Date const &,Period const &) const\n"
    "    YoYInflationTermStructure::yoyRate(Date const &) const\n"
    "    YoYInflationTermStructure::yoyRate(Time,bool) const\n"
    "    YoYInflationTermStructure::yoyRate(Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructure_indexIsInterpolated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructure_indexIsInterpolated" "', argument " "1"" of type '" "YoYInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((YoYInflationTermStructure const *)arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationTermStructure *arg1 = (YoYInflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempshared1 ;
  ext::shared_ptr< YoYInflationTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationTermStructure" "', argument " "1"" of type '" "YoYInflationTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationTermStructure > * >(argp1);
      arg1 = const_cast< YoYInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YoYInflationTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYInflationTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempshared1 ;
  Handle< YoYInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< YoYInflationTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< YoYInflationTermStructure > *)new Handle< YoYInflationTermStructure >((ext::shared_ptr< YoYInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< YoYInflationTermStructure > *)new Handle< YoYInflationTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYInflationTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_YoYInflationTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YoYInflationTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYInflationTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< YoYInflationTermStructure >::Handle(ext::shared_ptr< YoYInflationTermStructure > const &)\n"
    "    Handle< YoYInflationTermStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle___deref__" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationTermStructure > *smartresult = result ? new ext::shared_ptr<  YoYInflationTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationTermStructure > *smartresult = result ? new ext::shared_ptr<  YoYInflationTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_YoYInflationTermStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle___bool__" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_YoYInflationTermStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_YoYInflationTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationTermStructureHandle" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)(*arg1)->yoyRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)(*arg1)->yoyRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationTermStructureHandle_yoyRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Rate)(*arg1)->yoyRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_yoyRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYInflationTermStructureHandle_yoyRate", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYInflationTermStructureHandle_yoyRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYInflationTermStructureHandle_yoyRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYInflationTermStructure::yoyRate(Date const &,Period const &,bool,bool) const\n"
    "    YoYInflationTermStructure::yoyRate(Date const &,Period const &,bool) const\n"
    "    YoYInflationTermStructure::yoyRate(Date const &,Period const &) const\n"
    "    YoYInflationTermStructure::yoyRate(Date const &) const\n"
    "    YoYInflationTermStructure::yoyRate(Time,bool) const\n"
    "    YoYInflationTermStructure::yoyRate(Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_indexIsInterpolated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_indexIsInterpolated" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->indexIsInterpolated();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_observationLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_observationLag" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_frequency" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (Frequency)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_baseRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_baseRate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (Rate)(*arg1)->baseRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_baseDate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_setSeasonality__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< Seasonality > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Seasonality > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_setSeasonality" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructureHandle_setSeasonality" "', argument " "2"" of type '" "ext::shared_ptr< Seasonality > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (*arg1)->setSeasonality((ext::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_setSeasonality__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_setSeasonality" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      (*arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_setSeasonality(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYInflationTermStructureHandle_setSeasonality", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_YoYInflationTermStructureHandle_setSeasonality__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYInflationTermStructureHandle_setSeasonality__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYInflationTermStructureHandle_setSeasonality'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InflationTermStructure::setSeasonality(ext::shared_ptr< Seasonality > const &)\n"
    "    InflationTermStructure::setSeasonality()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_seasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Seasonality > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_seasonality" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->seasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Seasonality > *smartresult = result ? new ext::shared_ptr<  Seasonality >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_hasSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_hasSeasonality" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYInflationTermStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_calendar" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationTermStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYInflationTermStructure > *arg1 = (Handle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationTermStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableYoYInflationTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYInflationTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempshared1 ;
  RelinkableHandle< YoYInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableYoYInflationTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< YoYInflationTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< YoYInflationTermStructure > *)new RelinkableHandle< YoYInflationTermStructure >((ext::shared_ptr< YoYInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableYoYInflationTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< YoYInflationTermStructure > *)new RelinkableHandle< YoYInflationTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableYoYInflationTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableYoYInflationTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableYoYInflationTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableYoYInflationTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableYoYInflationTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< YoYInflationTermStructure >::RelinkableHandle(ext::shared_ptr< YoYInflationTermStructure > const &)\n"
    "    RelinkableHandle< YoYInflationTermStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableYoYInflationTermStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYInflationTermStructure > *arg1 = (RelinkableHandle< YoYInflationTermStructure > *) 0 ;
  ext::shared_ptr< YoYInflationTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YoYInflationTermStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableYoYInflationTermStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableYoYInflationTermStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YoYInflationTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableYoYInflationTermStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< YoYInflationTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YoYInflationTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableYoYInflationTermStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYInflationTermStructure > *arg1 = (RelinkableHandle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableYoYInflationTermStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_YoYInflationTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableYoYInflationTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< YoYInflationTermStructure > *arg1 = (RelinkableHandle< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableYoYInflationTermStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< YoYInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< YoYInflationTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableYoYInflationTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_YoYInflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableYoYInflationTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "1"" of type '" "ZeroInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "1"" of type '" "ZeroInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "1"" of type '" "ZeroInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "1"" of type '" "ZeroInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "1"" of type '" "ZeroInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure const > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "1"" of type '" "ZeroInflationTermStructure const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroInflationTermStructure_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Rate)((ZeroInflationTermStructure const *)arg1)->zeroRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructure_zeroRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroInflationTermStructure_zeroRate", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ZeroInflationTermStructure_zeroRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZeroInflationTermStructure_zeroRate__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ZeroInflationTermStructure_zeroRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZeroInflationTermStructure_zeroRate__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ZeroInflationTermStructure_zeroRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ZeroInflationTermStructure_zeroRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroInflationTermStructure_zeroRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &,Period const &,bool,bool) const\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &,Period const &,bool) const\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &,Period const &) const\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &) const\n"
    "    ZeroInflationTermStructure::zeroRate(Time,bool) const\n"
    "    ZeroInflationTermStructure::zeroRate(Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZeroInflationTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationTermStructure *arg1 = (ZeroInflationTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempshared1 ;
  ext::shared_ptr< ZeroInflationTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroInflationTermStructure" "', argument " "1"" of type '" "ZeroInflationTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroInflationTermStructure > * >(argp1);
      arg1 = const_cast< ZeroInflationTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroInflationTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ZeroInflationTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempshared1 ;
  Handle< ZeroInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< ZeroInflationTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< ZeroInflationTermStructure > *)new Handle< ZeroInflationTermStructure >((ext::shared_ptr< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< ZeroInflationTermStructure > *)new Handle< ZeroInflationTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroInflationTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ZeroInflationTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ZeroInflationTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroInflationTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< ZeroInflationTermStructure >::Handle(ext::shared_ptr< ZeroInflationTermStructure > const &)\n"
    "    Handle< ZeroInflationTermStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle___deref__" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationTermStructure > *smartresult = result ? new ext::shared_ptr<  ZeroInflationTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationTermStructure > *smartresult = result ? new ext::shared_ptr<  ZeroInflationTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_ZeroInflationTermStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle___bool__" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_ZeroInflationTermStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_ZeroInflationTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroInflationTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroInflationTermStructureHandle" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)(*arg1)->zeroRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)(*arg1)->zeroRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroInflationTermStructureHandle_zeroRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Rate)(*arg1)->zeroRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_zeroRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroInflationTermStructureHandle_zeroRate", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ZeroInflationTermStructureHandle_zeroRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroInflationTermStructureHandle_zeroRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &,Period const &,bool,bool) const\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &,Period const &,bool) const\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &,Period const &) const\n"
    "    ZeroInflationTermStructure::zeroRate(Date const &) const\n"
    "    ZeroInflationTermStructure::zeroRate(Time,bool) const\n"
    "    ZeroInflationTermStructure::zeroRate(Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_observationLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_observationLag" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->observationLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_frequency" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (Frequency)(*arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_baseRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_baseRate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (Rate)(*arg1)->baseRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_baseDate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_setSeasonality__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< Seasonality > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Seasonality > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_setSeasonality" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructureHandle_setSeasonality" "', argument " "2"" of type '" "ext::shared_ptr< Seasonality > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Seasonality > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (*arg1)->setSeasonality((ext::shared_ptr< Seasonality > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_setSeasonality__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_setSeasonality" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      (*arg1)->setSeasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_setSeasonality(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroInflationTermStructureHandle_setSeasonality", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ZeroInflationTermStructureHandle_setSeasonality__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ZeroInflationTermStructureHandle_setSeasonality__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroInflationTermStructureHandle_setSeasonality'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InflationTermStructure::setSeasonality(ext::shared_ptr< Seasonality > const &)\n"
    "    InflationTermStructure::setSeasonality()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_seasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Seasonality > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_seasonality" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->seasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Seasonality > *smartresult = result ? new ext::shared_ptr<  Seasonality >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Seasonality_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_hasSeasonality(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_hasSeasonality" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->hasSeasonality();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroInflationTermStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_calendar" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationTermStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = (Handle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationTermStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroInflationTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroInflationTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableZeroInflationTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempshared1 ;
  RelinkableHandle< ZeroInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableZeroInflationTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< ZeroInflationTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< ZeroInflationTermStructure > *)new RelinkableHandle< ZeroInflationTermStructure >((ext::shared_ptr< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableZeroInflationTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< ZeroInflationTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< ZeroInflationTermStructure > *)new RelinkableHandle< ZeroInflationTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableZeroInflationTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableZeroInflationTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableZeroInflationTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableZeroInflationTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableZeroInflationTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< ZeroInflationTermStructure >::RelinkableHandle(ext::shared_ptr< ZeroInflationTermStructure > const &)\n"
    "    RelinkableHandle< ZeroInflationTermStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableZeroInflationTermStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< ZeroInflationTermStructure > *arg1 = (RelinkableHandle< ZeroInflationTermStructure > *) 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ZeroInflationTermStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableZeroInflationTermStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableZeroInflationTermStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< ZeroInflationTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableZeroInflationTermStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< ZeroInflationTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ZeroInflationTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableZeroInflationTermStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< ZeroInflationTermStructure > *arg1 = (RelinkableHandle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableZeroInflationTermStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_ZeroInflationTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableZeroInflationTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< ZeroInflationTermStructure > *arg1 = (RelinkableHandle< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableZeroInflationTermStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< ZeroInflationTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableZeroInflationTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_ZeroInflationTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableZeroInflationTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Region_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Region *arg1 = (Region *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Region, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_name" "', argument " "1"" of type '" "Region const *""'"); 
  }
  arg1 = reinterpret_cast< Region * >(argp1);
  {
    try {
      result = ((Region const *)arg1)->name();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Region_code(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Region *arg1 = (Region *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Region, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Region_code" "', argument " "1"" of type '" "Region const *""'"); 
  }
  arg1 = reinterpret_cast< Region * >(argp1);
  {
    try {
      result = ((Region const *)arg1)->code();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Region(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Region *arg1 = (Region *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Region, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Region" "', argument " "1"" of type '" "Region *""'"); 
  }
  arg1 = reinterpret_cast< Region * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Region_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Region, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CustomRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  CustomRegion *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CustomRegion", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomRegion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomRegion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CustomRegion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomRegion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (CustomRegion *)new CustomRegion((std::string const &)*arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CustomRegion, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CustomRegion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CustomRegion *arg1 = (CustomRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CustomRegion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CustomRegion" "', argument " "1"" of type '" "CustomRegion *""'"); 
  }
  arg1 = reinterpret_cast< CustomRegion * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CustomRegion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CustomRegion, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CustomRegion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_InflationIndex_familyName(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_familyName" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationIndex const *)arg1)->familyName();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_region(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Region > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_region" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationIndex const *)arg1)->region();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Region(result)), SWIGTYPE_p_Region, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_revised(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_revised" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((InflationIndex const *)arg1)->revised();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_interpolated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_interpolated" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((InflationIndex const *)arg1)->interpolated();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_frequency" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)((InflationIndex const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_availabilityLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_availabilityLag" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationIndex const *)arg1)->availabilityLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationIndex_currency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex const > tempshared1 ;
  ext::shared_ptr< InflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Currency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationIndex_currency" "', argument " "1"" of type '" "InflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationIndex const *)arg1)->currency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Currency(result)), SWIGTYPE_p_Currency, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InflationIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationIndex *arg1 = (InflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationIndex > tempshared1 ;
  ext::shared_ptr< InflationIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InflationIndex" "', argument " "1"" of type '" "InflationIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InflationIndex > * >(argp1);
      arg1 = const_cast< InflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InflationIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ZeroInflationIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  Frequency arg4 ;
  Period *arg5 = 0 ;
  Currency *arg6 = 0 ;
  Handle< ZeroInflationTermStructure > *arg7 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ZeroInflationIndex *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZeroInflationIndex" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroInflationIndex" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Currency const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Currency const &""'"); 
  }
  arg6 = reinterpret_cast< Currency * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationIndex" "', argument " "7"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "7"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp7);
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,(Period const &)*arg5,(Currency const &)*arg6,(Handle< ZeroInflationTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  Frequency arg4 ;
  Period *arg5 = 0 ;
  Currency *arg6 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ZeroInflationIndex *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZeroInflationIndex" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroInflationIndex" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Currency const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Currency const &""'"); 
  }
  arg6 = reinterpret_cast< Currency * >(argp6);
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,(Period const &)*arg5,(Currency const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Frequency arg5 ;
  Period *arg6 = 0 ;
  Currency *arg7 = 0 ;
  Handle< ZeroInflationTermStructure > *arg8 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  ZeroInflationIndex *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZeroInflationIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroInflationIndex" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  arg7 = reinterpret_cast< Currency * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ZeroInflationIndex" "', argument " "8"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "8"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp8);
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency const &)*arg7,(Handle< ZeroInflationTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationIndex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Frequency arg5 ;
  Period *arg6 = 0 ;
  Currency *arg7 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ZeroInflationIndex *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZeroInflationIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroInflationIndex" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  arg7 = reinterpret_cast< Currency * >(argp7);
  {
    try {
      result = (ZeroInflationIndex *)new ZeroInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroInflationIndex", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_ZeroInflationIndex__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ZeroInflationIndex__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ZeroInflationIndex__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_ZeroInflationIndex__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroInflationIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroInflationIndex::ZeroInflationIndex(std::string const &,Region const &,bool,Frequency,Period const &,Currency const &,Handle< ZeroInflationTermStructure > const &)\n"
    "    ZeroInflationIndex::ZeroInflationIndex(std::string const &,Region const &,bool,Frequency,Period const &,Currency const &)\n"
    "    ZeroInflationIndex::ZeroInflationIndex(std::string const &,Region const &,bool,bool,Frequency,Period const &,Currency const &,Handle< ZeroInflationTermStructure > const &)\n"
    "    ZeroInflationIndex::ZeroInflationIndex(std::string const &,Region const &,bool,bool,Frequency,Period const &,Currency const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroInflationIndex_zeroInflationTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationIndex *arg1 = (ZeroInflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex const > tempshared1 ;
  ext::shared_ptr< ZeroInflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< ZeroInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationIndex_zeroInflationTermStructure" "', argument " "1"" of type '" "ZeroInflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationIndex > * >(argp1);
      arg1 = const_cast< ZeroInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationIndex > * >(argp1);
      arg1 = const_cast< ZeroInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ZeroInflationIndex const *)arg1)->zeroInflationTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< ZeroInflationTermStructure >(result)), SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationIndex_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationIndex *arg1 = (ZeroInflationIndex *) 0 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex const > tempshared1 ;
  ext::shared_ptr< ZeroInflationIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroInflationIndex_clone", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationIndex_clone" "', argument " "1"" of type '" "ZeroInflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationIndex > * >(argp1);
      arg1 = const_cast< ZeroInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationIndex > * >(argp1);
      arg1 = const_cast< ZeroInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroInflationIndex_clone" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroInflationIndex_clone" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = ((ZeroInflationIndex const *)arg1)->clone((Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroInflationIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationIndex *arg1 = (ZeroInflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared1 ;
  ext::shared_ptr< ZeroInflationIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroInflationIndex" "', argument " "1"" of type '" "ZeroInflationIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroInflationIndex > * >(argp1);
      arg1 = const_cast< ZeroInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroInflationIndex > * >(argp1);
      arg1 = const_cast< ZeroInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroInflationIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroInflationIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_zero_inflation_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Index > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Index > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Index_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_zero_inflation_index" "', argument " "1"" of type '" "ext::shared_ptr< Index > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Index > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Index > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Index > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_zero_inflation_index((ext::shared_ptr< Index > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ZeroInflationIndex > *arg1 = 0 ;
  bool arg2 ;
  Handle< YoYInflationTermStructure > arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  YoYInflationIndex *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationIndex" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure >""'");
    } else {
      Handle< YoYInflationTermStructure > * temp = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((ext::shared_ptr< ZeroInflationIndex > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ZeroInflationIndex > *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  YoYInflationIndex *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((ext::shared_ptr< ZeroInflationIndex > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Frequency arg5 ;
  Period *arg6 = 0 ;
  Currency *arg7 = 0 ;
  Handle< YoYInflationTermStructure > arg8 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  YoYInflationIndex *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_YoYInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationIndex" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  arg7 = reinterpret_cast< Currency * >(argp7);
  {
    res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationIndex" "', argument " "8"" of type '" "Handle< YoYInflationTermStructure >""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "8"" of type '" "Handle< YoYInflationTermStructure >""'");
    } else {
      Handle< YoYInflationTermStructure > * temp = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Frequency arg5 ;
  Period *arg6 = 0 ;
  Currency *arg7 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  YoYInflationIndex *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_YoYInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationIndex" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Currency const &""'"); 
  }
  arg7 = reinterpret_cast< Currency * >(argp7);
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,(Period const &)*arg6,(Currency const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  Frequency arg6 ;
  Period *arg7 = 0 ;
  Currency *arg8 = 0 ;
  Handle< YoYInflationTermStructure > *arg9 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  YoYInflationIndex *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_YoYInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationIndex" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_YoYInflationIndex" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationIndex" "', argument " "8"" of type '" "Currency const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "8"" of type '" "Currency const &""'"); 
  }
  arg8 = reinterpret_cast< Currency * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_YoYInflationIndex" "', argument " "9"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "9"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp9);
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,arg6,(Period const &)*arg7,(Currency const &)*arg8,(Handle< YoYInflationTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  Region *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  Frequency arg6 ;
  Period *arg7 = 0 ;
  Currency *arg8 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  YoYInflationIndex *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Region,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "2"" of type '" "Region const &""'"); 
  }
  arg2 = reinterpret_cast< Region * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_YoYInflationIndex" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationIndex" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationIndex" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_YoYInflationIndex" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationIndex" "', argument " "8"" of type '" "Currency const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationIndex" "', argument " "8"" of type '" "Currency const &""'"); 
  }
  arg8 = reinterpret_cast< Currency * >(argp8);
  {
    try {
      result = (YoYInflationIndex *)new YoYInflationIndex((std::string const &)*arg1,(Region const &)*arg2,arg3,arg4,arg5,arg6,(Period const &)*arg7,(Currency const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationIndex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYInflationIndex", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_YoYInflationIndex__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_YoYInflationIndex__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_YoYInflationIndex__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_YoYInflationIndex__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_YoYInflationIndex__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Region, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_YoYInflationIndex__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYInflationIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYInflationIndex::YoYInflationIndex(ext::shared_ptr< ZeroInflationIndex > const &,bool,Handle< YoYInflationTermStructure >)\n"
    "    YoYInflationIndex::YoYInflationIndex(ext::shared_ptr< ZeroInflationIndex > const &,bool)\n"
    "    YoYInflationIndex::YoYInflationIndex(std::string const &,Region const &,bool,bool,Frequency,Period const &,Currency const &,Handle< YoYInflationTermStructure >)\n"
    "    YoYInflationIndex::YoYInflationIndex(std::string const &,Region const &,bool,bool,Frequency,Period const &,Currency const &)\n"
    "    YoYInflationIndex::YoYInflationIndex(std::string const &,Region const &,bool,bool,bool,Frequency,Period const &,Currency const &,Handle< YoYInflationTermStructure > const &)\n"
    "    YoYInflationIndex::YoYInflationIndex(std::string const &,Region const &,bool,bool,bool,Frequency,Period const &,Currency const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationIndex_ratio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex const > tempshared1 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationIndex_ratio" "', argument " "1"" of type '" "YoYInflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((YoYInflationIndex const *)arg1)->ratio();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationIndex_underlyingIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex const > tempshared1 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationIndex_underlyingIndex" "', argument " "1"" of type '" "YoYInflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYInflationIndex const *)arg1)->underlyingIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationIndex_yoyInflationTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex const > tempshared1 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YoYInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationIndex_yoyInflationTermStructure" "', argument " "1"" of type '" "YoYInflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYInflationIndex const *)arg1)->yoyInflationTermStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YoYInflationTermStructure >(result)), SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationIndex_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex const > tempshared1 ;
  ext::shared_ptr< YoYInflationIndex const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< YoYInflationIndex > result;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYInflationIndex_clone", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationIndex_clone" "', argument " "1"" of type '" "YoYInflationIndex const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYInflationIndex_clone" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationIndex_clone" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = ((YoYInflationIndex const *)arg1)->clone((Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationIndex *arg1 = (YoYInflationIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared1 ;
  ext::shared_ptr< YoYInflationIndex > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationIndex" "', argument " "1"" of type '" "YoYInflationIndex *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationIndex > * >(argp1);
      arg1 = const_cast< YoYInflationIndex * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationIndex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EUHICP__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EUHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EUHICP" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EUHICP" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (EUHICP *)new EUHICP((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICP > *smartresult = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICP__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EUHICP *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EUHICP *)new EUHICP();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICP > *smartresult = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICP__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EUHICP *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EUHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EUHICP" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EUHICP" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = (EUHICP *)new EUHICP(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICP > *smartresult = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICP__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  EUHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EUHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (EUHICP *)new EUHICP(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICP > *smartresult = result ? new ext::shared_ptr<  EUHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EUHICP", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EUHICP__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EUHICP__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EUHICP__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EUHICP__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EUHICP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EUHICP::EUHICP(Handle< ZeroInflationTermStructure > const &)\n"
    "    EUHICP::EUHICP()\n"
    "    EUHICP::EUHICP(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    EUHICP::EUHICP(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EUHICP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EUHICP *arg1 = (EUHICP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EUHICP > tempshared1 ;
  ext::shared_ptr< EUHICP > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EUHICP_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EUHICP" "', argument " "1"" of type '" "EUHICP *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EUHICP > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EUHICP > * >(argp1);
      arg1 = const_cast< EUHICP * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EUHICP > * >(argp1);
      arg1 = const_cast< EUHICP * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EUHICP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EUHICP_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EUHICP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EUHICPXT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  EUHICPXT *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EUHICPXT" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EUHICPXT" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (EUHICPXT *)new EUHICPXT((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICPXT > *smartresult = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICPXT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  EUHICPXT *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (EUHICPXT *)new EUHICPXT();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICPXT > *smartresult = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICPXT__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  EUHICPXT *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EUHICPXT" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EUHICPXT" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EUHICPXT" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = (EUHICPXT *)new EUHICPXT(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICPXT > *smartresult = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICPXT__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  EUHICPXT *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EUHICPXT" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (EUHICPXT *)new EUHICPXT(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  EUHICPXT > *smartresult = result ? new ext::shared_ptr<  EUHICPXT >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EUHICPXT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EUHICPXT", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_EUHICPXT__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EUHICPXT__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EUHICPXT__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EUHICPXT__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EUHICPXT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EUHICPXT::EUHICPXT(Handle< ZeroInflationTermStructure > const &)\n"
    "    EUHICPXT::EUHICPXT()\n"
    "    EUHICPXT::EUHICPXT(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    EUHICPXT::EUHICPXT(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EUHICPXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EUHICPXT *arg1 = (EUHICPXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< EUHICPXT > tempshared1 ;
  ext::shared_ptr< EUHICPXT > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EUHICPXT" "', argument " "1"" of type '" "EUHICPXT *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  EUHICPXT > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  EUHICPXT > * >(argp1);
      arg1 = const_cast< EUHICPXT * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  EUHICPXT > * >(argp1);
      arg1 = const_cast< EUHICPXT * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EUHICPXT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_EUHICPXT_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EUHICPXT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FRHICP__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FRHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FRHICP" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FRHICP" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (FRHICP *)new FRHICP((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FRHICP > *smartresult = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FRHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FRHICP__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  FRHICP *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (FRHICP *)new FRHICP();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FRHICP > *smartresult = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FRHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FRHICP__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FRHICP *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FRHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FRHICP" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FRHICP" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = (FRHICP *)new FRHICP(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FRHICP > *smartresult = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FRHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FRHICP__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  FRHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FRHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (FRHICP *)new FRHICP(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FRHICP > *smartresult = result ? new ext::shared_ptr<  FRHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FRHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FRHICP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FRHICP", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FRHICP__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FRHICP__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FRHICP__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FRHICP__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FRHICP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FRHICP::FRHICP(Handle< ZeroInflationTermStructure > const &)\n"
    "    FRHICP::FRHICP()\n"
    "    FRHICP::FRHICP(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    FRHICP::FRHICP(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FRHICP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FRHICP *arg1 = (FRHICP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FRHICP > tempshared1 ;
  ext::shared_ptr< FRHICP > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FRHICP_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FRHICP" "', argument " "1"" of type '" "FRHICP *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FRHICP > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FRHICP > * >(argp1);
      arg1 = const_cast< FRHICP * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FRHICP > * >(argp1);
      arg1 = const_cast< FRHICP * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FRHICP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FRHICP_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FRHICP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UKRPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UKRPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UKRPI" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UKRPI" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (UKRPI *)new UKRPI((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UKRPI > *smartresult = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UKRPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UKRPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  UKRPI *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (UKRPI *)new UKRPI();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UKRPI > *smartresult = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UKRPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UKRPI__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  UKRPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UKRPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UKRPI" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UKRPI" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = (UKRPI *)new UKRPI(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UKRPI > *smartresult = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UKRPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UKRPI__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  UKRPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UKRPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (UKRPI *)new UKRPI(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UKRPI > *smartresult = result ? new ext::shared_ptr<  UKRPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UKRPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UKRPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UKRPI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UKRPI__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UKRPI__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UKRPI__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UKRPI__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UKRPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UKRPI::UKRPI(Handle< ZeroInflationTermStructure > const &)\n"
    "    UKRPI::UKRPI()\n"
    "    UKRPI::UKRPI(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    UKRPI::UKRPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UKRPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UKRPI *arg1 = (UKRPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UKRPI > tempshared1 ;
  ext::shared_ptr< UKRPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UKRPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UKRPI" "', argument " "1"" of type '" "UKRPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UKRPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UKRPI > * >(argp1);
      arg1 = const_cast< UKRPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UKRPI > * >(argp1);
      arg1 = const_cast< UKRPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UKRPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UKRPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UKRPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_USCPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  USCPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USCPI" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USCPI" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (USCPI *)new USCPI((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USCPI > *smartresult = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USCPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  USCPI *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (USCPI *)new USCPI();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USCPI > *smartresult = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USCPI__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  USCPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_USCPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_USCPI" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USCPI" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = (USCPI *)new USCPI(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USCPI > *smartresult = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USCPI__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  USCPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_USCPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (USCPI *)new USCPI(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  USCPI > *smartresult = result ? new ext::shared_ptr<  USCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_USCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_USCPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_USCPI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_USCPI__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_USCPI__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_USCPI__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_USCPI__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_USCPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    USCPI::USCPI(Handle< ZeroInflationTermStructure > const &)\n"
    "    USCPI::USCPI()\n"
    "    USCPI::USCPI(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    USCPI::USCPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_USCPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  USCPI *arg1 = (USCPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< USCPI > tempshared1 ;
  ext::shared_ptr< USCPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_USCPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_USCPI" "', argument " "1"" of type '" "USCPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  USCPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  USCPI > * >(argp1);
      arg1 = const_cast< USCPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  USCPI > * >(argp1);
      arg1 = const_cast< USCPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *USCPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_USCPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *USCPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZACPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ZACPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZACPI" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZACPI" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (ZACPI *)new ZACPI((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZACPI > *smartresult = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZACPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZACPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ZACPI *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ZACPI *)new ZACPI();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZACPI > *smartresult = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZACPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZACPI__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< ZeroInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ZACPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZACPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZACPI" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZACPI" "', argument " "2"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp2);
  {
    try {
      result = (ZACPI *)new ZACPI(arg1,(Handle< ZeroInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZACPI > *smartresult = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZACPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZACPI__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  ZACPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZACPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (ZACPI *)new ZACPI(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZACPI > *smartresult = result ? new ext::shared_ptr<  ZACPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZACPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZACPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZACPI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ZACPI__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ZACPI__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ZACPI__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ZACPI__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZACPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZACPI::ZACPI(Handle< ZeroInflationTermStructure > const &)\n"
    "    ZACPI::ZACPI()\n"
    "    ZACPI::ZACPI(bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    ZACPI::ZACPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ZACPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZACPI *arg1 = (ZACPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZACPI > tempshared1 ;
  ext::shared_ptr< ZACPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZACPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZACPI" "', argument " "1"" of type '" "ZACPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZACPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZACPI > * >(argp1);
      arg1 = const_cast< ZACPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZACPI > * >(argp1);
      arg1 = const_cast< ZACPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZACPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZACPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZACPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UKHICP__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ZeroInflationTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  UKHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UKHICP" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UKHICP" "', argument " "1"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp1);
  {
    try {
      result = (UKHICP *)new UKHICP((Handle< ZeroInflationTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UKHICP > *smartresult = result ? new ext::shared_ptr<  UKHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UKHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UKHICP__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  UKHICP *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (UKHICP *)new UKHICP();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UKHICP > *smartresult = result ? new ext::shared_ptr<  UKHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UKHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UKHICP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UKHICP", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UKHICP__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UKHICP__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UKHICP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UKHICP::UKHICP(Handle< ZeroInflationTermStructure > const &)\n"
    "    UKHICP::UKHICP()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UKHICP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UKHICP *arg1 = (UKHICP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UKHICP > tempshared1 ;
  ext::shared_ptr< UKHICP > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UKHICP_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UKHICP" "', argument " "1"" of type '" "UKHICP *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UKHICP > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UKHICP > * >(argp1);
      arg1 = const_cast< UKHICP * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UKHICP > * >(argp1);
      arg1 = const_cast< UKHICP * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UKHICP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UKHICP_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UKHICP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYEUHICP__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYEUHICP *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYEUHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYEUHICP" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYEUHICP" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYEUHICP *)new YYEUHICP(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYEUHICP > *smartresult = result ? new ext::shared_ptr<  YYEUHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYEUHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYEUHICP__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYEUHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYEUHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYEUHICP *)new YYEUHICP(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYEUHICP > *smartresult = result ? new ext::shared_ptr<  YYEUHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYEUHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYEUHICP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYEUHICP", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYEUHICP__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYEUHICP__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYEUHICP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYEUHICP::YYEUHICP(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYEUHICP::YYEUHICP(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYEUHICP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYEUHICP *arg1 = (YYEUHICP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYEUHICP > tempshared1 ;
  ext::shared_ptr< YYEUHICP > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYEUHICP_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYEUHICP" "', argument " "1"" of type '" "YYEUHICP *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYEUHICP > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYEUHICP > * >(argp1);
      arg1 = const_cast< YYEUHICP * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYEUHICP > * >(argp1);
      arg1 = const_cast< YYEUHICP * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYEUHICP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYEUHICP_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYEUHICP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYEUHICPXT__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYEUHICPXT *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYEUHICPXT" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYEUHICPXT" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYEUHICPXT" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYEUHICPXT *)new YYEUHICPXT(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYEUHICPXT > *smartresult = result ? new ext::shared_ptr<  YYEUHICPXT >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYEUHICPXT_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYEUHICPXT__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYEUHICPXT *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYEUHICPXT" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYEUHICPXT *)new YYEUHICPXT(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYEUHICPXT > *smartresult = result ? new ext::shared_ptr<  YYEUHICPXT >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYEUHICPXT_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYEUHICPXT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYEUHICPXT", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYEUHICPXT__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYEUHICPXT__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYEUHICPXT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYEUHICPXT::YYEUHICPXT(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYEUHICPXT::YYEUHICPXT(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYEUHICPXT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYEUHICPXT *arg1 = (YYEUHICPXT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYEUHICPXT > tempshared1 ;
  ext::shared_ptr< YYEUHICPXT > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYEUHICPXT_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYEUHICPXT" "', argument " "1"" of type '" "YYEUHICPXT *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYEUHICPXT > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYEUHICPXT > * >(argp1);
      arg1 = const_cast< YYEUHICPXT * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYEUHICPXT > * >(argp1);
      arg1 = const_cast< YYEUHICPXT * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYEUHICPXT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYEUHICPXT_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYEUHICPXT_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYEUHICPr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYEUHICPr *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYEUHICPr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYEUHICPr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYEUHICPr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYEUHICPr *)new YYEUHICPr(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYEUHICPr > *smartresult = result ? new ext::shared_ptr<  YYEUHICPr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYEUHICPr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYEUHICPr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYEUHICPr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYEUHICPr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYEUHICPr *)new YYEUHICPr(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYEUHICPr > *smartresult = result ? new ext::shared_ptr<  YYEUHICPr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYEUHICPr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYEUHICPr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYEUHICPr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYEUHICPr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYEUHICPr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYEUHICPr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYEUHICPr::YYEUHICPr(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYEUHICPr::YYEUHICPr(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYEUHICPr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYEUHICPr *arg1 = (YYEUHICPr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYEUHICPr > tempshared1 ;
  ext::shared_ptr< YYEUHICPr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYEUHICPr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYEUHICPr" "', argument " "1"" of type '" "YYEUHICPr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYEUHICPr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYEUHICPr > * >(argp1);
      arg1 = const_cast< YYEUHICPr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYEUHICPr > * >(argp1);
      arg1 = const_cast< YYEUHICPr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYEUHICPr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYEUHICPr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYEUHICPr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYFRHICP__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYFRHICP *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYFRHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYFRHICP" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYFRHICP" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYFRHICP *)new YYFRHICP(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYFRHICP > *smartresult = result ? new ext::shared_ptr<  YYFRHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYFRHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYFRHICP__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYFRHICP *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYFRHICP" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYFRHICP *)new YYFRHICP(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYFRHICP > *smartresult = result ? new ext::shared_ptr<  YYFRHICP >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYFRHICP_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYFRHICP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYFRHICP", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYFRHICP__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYFRHICP__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYFRHICP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYFRHICP::YYFRHICP(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYFRHICP::YYFRHICP(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYFRHICP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYFRHICP *arg1 = (YYFRHICP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYFRHICP > tempshared1 ;
  ext::shared_ptr< YYFRHICP > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYFRHICP_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYFRHICP" "', argument " "1"" of type '" "YYFRHICP *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYFRHICP > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYFRHICP > * >(argp1);
      arg1 = const_cast< YYFRHICP * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYFRHICP > * >(argp1);
      arg1 = const_cast< YYFRHICP * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYFRHICP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYFRHICP_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYFRHICP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYFRHICPr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYFRHICPr *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYFRHICPr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYFRHICPr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYFRHICPr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYFRHICPr *)new YYFRHICPr(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYFRHICPr > *smartresult = result ? new ext::shared_ptr<  YYFRHICPr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYFRHICPr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYFRHICPr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYFRHICPr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYFRHICPr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYFRHICPr *)new YYFRHICPr(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYFRHICPr > *smartresult = result ? new ext::shared_ptr<  YYFRHICPr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYFRHICPr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYFRHICPr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYFRHICPr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYFRHICPr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYFRHICPr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYFRHICPr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYFRHICPr::YYFRHICPr(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYFRHICPr::YYFRHICPr(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYFRHICPr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYFRHICPr *arg1 = (YYFRHICPr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYFRHICPr > tempshared1 ;
  ext::shared_ptr< YYFRHICPr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYFRHICPr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYFRHICPr" "', argument " "1"" of type '" "YYFRHICPr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYFRHICPr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYFRHICPr > * >(argp1);
      arg1 = const_cast< YYFRHICPr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYFRHICPr > * >(argp1);
      arg1 = const_cast< YYFRHICPr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYFRHICPr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYFRHICPr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYFRHICPr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYUKRPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYUKRPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUKRPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYUKRPI" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYUKRPI" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYUKRPI *)new YYUKRPI(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUKRPI > *smartresult = result ? new ext::shared_ptr<  YYUKRPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUKRPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUKRPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYUKRPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUKRPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYUKRPI *)new YYUKRPI(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUKRPI > *smartresult = result ? new ext::shared_ptr<  YYUKRPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUKRPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUKRPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYUKRPI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYUKRPI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYUKRPI__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYUKRPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYUKRPI::YYUKRPI(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYUKRPI::YYUKRPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYUKRPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYUKRPI *arg1 = (YYUKRPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYUKRPI > tempshared1 ;
  ext::shared_ptr< YYUKRPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYUKRPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYUKRPI" "', argument " "1"" of type '" "YYUKRPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYUKRPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYUKRPI > * >(argp1);
      arg1 = const_cast< YYUKRPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYUKRPI > * >(argp1);
      arg1 = const_cast< YYUKRPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYUKRPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYUKRPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYUKRPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYUKRPIr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYUKRPIr *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUKRPIr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYUKRPIr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYUKRPIr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYUKRPIr *)new YYUKRPIr(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUKRPIr > *smartresult = result ? new ext::shared_ptr<  YYUKRPIr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUKRPIr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUKRPIr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYUKRPIr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUKRPIr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYUKRPIr *)new YYUKRPIr(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUKRPIr > *smartresult = result ? new ext::shared_ptr<  YYUKRPIr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUKRPIr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUKRPIr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYUKRPIr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYUKRPIr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYUKRPIr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYUKRPIr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYUKRPIr::YYUKRPIr(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYUKRPIr::YYUKRPIr(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYUKRPIr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYUKRPIr *arg1 = (YYUKRPIr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYUKRPIr > tempshared1 ;
  ext::shared_ptr< YYUKRPIr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYUKRPIr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYUKRPIr" "', argument " "1"" of type '" "YYUKRPIr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYUKRPIr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYUKRPIr > * >(argp1);
      arg1 = const_cast< YYUKRPIr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYUKRPIr > * >(argp1);
      arg1 = const_cast< YYUKRPIr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYUKRPIr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYUKRPIr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYUKRPIr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYUSCPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYUSCPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUSCPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYUSCPI" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYUSCPI" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYUSCPI *)new YYUSCPI(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUSCPI > *smartresult = result ? new ext::shared_ptr<  YYUSCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUSCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUSCPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYUSCPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUSCPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYUSCPI *)new YYUSCPI(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUSCPI > *smartresult = result ? new ext::shared_ptr<  YYUSCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUSCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUSCPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYUSCPI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYUSCPI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYUSCPI__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYUSCPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYUSCPI::YYUSCPI(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYUSCPI::YYUSCPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYUSCPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYUSCPI *arg1 = (YYUSCPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYUSCPI > tempshared1 ;
  ext::shared_ptr< YYUSCPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYUSCPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYUSCPI" "', argument " "1"" of type '" "YYUSCPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYUSCPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYUSCPI > * >(argp1);
      arg1 = const_cast< YYUSCPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYUSCPI > * >(argp1);
      arg1 = const_cast< YYUSCPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYUSCPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYUSCPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYUSCPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYUSCPIr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYUSCPIr *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUSCPIr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYUSCPIr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYUSCPIr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYUSCPIr *)new YYUSCPIr(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUSCPIr > *smartresult = result ? new ext::shared_ptr<  YYUSCPIr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUSCPIr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUSCPIr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYUSCPIr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYUSCPIr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYUSCPIr *)new YYUSCPIr(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYUSCPIr > *smartresult = result ? new ext::shared_ptr<  YYUSCPIr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYUSCPIr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYUSCPIr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYUSCPIr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYUSCPIr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYUSCPIr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYUSCPIr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYUSCPIr::YYUSCPIr(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYUSCPIr::YYUSCPIr(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYUSCPIr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYUSCPIr *arg1 = (YYUSCPIr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYUSCPIr > tempshared1 ;
  ext::shared_ptr< YYUSCPIr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYUSCPIr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYUSCPIr" "', argument " "1"" of type '" "YYUSCPIr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYUSCPIr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYUSCPIr > * >(argp1);
      arg1 = const_cast< YYUSCPIr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYUSCPIr > * >(argp1);
      arg1 = const_cast< YYUSCPIr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYUSCPIr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYUSCPIr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYUSCPIr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYZACPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYZACPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYZACPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYZACPI" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYZACPI" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYZACPI *)new YYZACPI(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYZACPI > *smartresult = result ? new ext::shared_ptr<  YYZACPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYZACPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYZACPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYZACPI *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYZACPI" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYZACPI *)new YYZACPI(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYZACPI > *smartresult = result ? new ext::shared_ptr<  YYZACPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYZACPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYZACPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYZACPI", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYZACPI__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYZACPI__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYZACPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYZACPI::YYZACPI(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYZACPI::YYZACPI(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYZACPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYZACPI *arg1 = (YYZACPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYZACPI > tempshared1 ;
  ext::shared_ptr< YYZACPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYZACPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYZACPI" "', argument " "1"" of type '" "YYZACPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYZACPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYZACPI > * >(argp1);
      arg1 = const_cast< YYZACPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYZACPI > * >(argp1);
      arg1 = const_cast< YYZACPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYZACPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYZACPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYZACPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YYZACPIr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Handle< YoYInflationTermStructure > *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  YYZACPIr *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYZACPIr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YYZACPIr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YYZACPIr" "', argument " "2"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp2);
  {
    try {
      result = (YYZACPIr *)new YYZACPIr(arg1,(Handle< YoYInflationTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYZACPIr > *smartresult = result ? new ext::shared_ptr<  YYZACPIr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYZACPIr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYZACPIr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  YYZACPIr *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YYZACPIr" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (YYZACPIr *)new YYZACPIr(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YYZACPIr > *smartresult = result ? new ext::shared_ptr<  YYZACPIr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YYZACPIr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YYZACPIr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YYZACPIr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YYZACPIr__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YYZACPIr__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YYZACPIr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YYZACPIr::YYZACPIr(bool,Handle< YoYInflationTermStructure > const &)\n"
    "    YYZACPIr::YYZACPIr(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YYZACPIr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YYZACPIr *arg1 = (YYZACPIr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YYZACPIr > tempshared1 ;
  ext::shared_ptr< YYZACPIr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YYZACPIr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YYZACPIr" "', argument " "1"" of type '" "YYZACPIr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YYZACPIr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YYZACPIr > * >(argp1);
      arg1 = const_cast< YYZACPIr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YYZACPIr > * >(argp1);
      arg1 = const_cast< YYZACPIr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YYZACPIr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YYZACPIr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YYZACPIr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AUCPI__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Frequency arg1 ;
  bool arg2 ;
  Handle< ZeroInflationTermStructure > *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  AUCPI *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AUCPI" "', argument " "1"" of type '" "Frequency""'");
  } 
  arg1 = static_cast< Frequency >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AUCPI" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AUCPI" "', argument " "3"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AUCPI" "', argument " "3"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp3);
  {
    try {
      result = (AUCPI *)new AUCPI(arg1,arg2,(Handle< ZeroInflationTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AUCPI > *smartresult = result ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AUCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AUCPI__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Frequency arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  AUCPI *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AUCPI" "', argument " "1"" of type '" "Frequency""'");
  } 
  arg1 = static_cast< Frequency >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AUCPI" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (AUCPI *)new AUCPI(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AUCPI > *smartresult = result ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AUCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AUCPI__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Frequency arg1 ;
  bool arg2 ;
  bool arg3 ;
  Handle< ZeroInflationTermStructure > *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  AUCPI *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AUCPI" "', argument " "1"" of type '" "Frequency""'");
  } 
  arg1 = static_cast< Frequency >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AUCPI" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AUCPI" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AUCPI" "', argument " "4"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AUCPI" "', argument " "4"" of type '" "Handle< ZeroInflationTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< ZeroInflationTermStructure > * >(argp4);
  {
    try {
      result = (AUCPI *)new AUCPI(arg1,arg2,arg3,(Handle< ZeroInflationTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AUCPI > *smartresult = result ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AUCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AUCPI__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Frequency arg1 ;
  bool arg2 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  AUCPI *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AUCPI" "', argument " "1"" of type '" "Frequency""'");
  } 
  arg1 = static_cast< Frequency >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AUCPI" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AUCPI" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (AUCPI *)new AUCPI(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AUCPI > *smartresult = result ? new ext::shared_ptr<  AUCPI >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AUCPI_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AUCPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AUCPI", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AUCPI__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_AUCPI__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AUCPI__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_ZeroInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_AUCPI__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AUCPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AUCPI::AUCPI(Frequency,bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    AUCPI::AUCPI(Frequency,bool)\n"
    "    AUCPI::AUCPI(Frequency,bool,bool,Handle< ZeroInflationTermStructure > const &)\n"
    "    AUCPI::AUCPI(Frequency,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AUCPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AUCPI *arg1 = (AUCPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AUCPI > tempshared1 ;
  ext::shared_ptr< AUCPI > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AUCPI_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AUCPI" "', argument " "1"" of type '" "AUCPI *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AUCPI > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AUCPI > * >(argp1);
      arg1 = const_cast< AUCPI * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AUCPI > * >(argp1);
      arg1 = const_cast< AUCPI * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AUCPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AUCPI_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AUCPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CPI_laggedFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ZeroInflationIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  CPI::InterpolationType arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CPI_laggedFixing", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPI_laggedFixing" "', argument " "1"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPI_laggedFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPI_laggedFixing" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPI_laggedFixing" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPI_laggedFixing" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CPI_laggedFixing" "', argument " "4"" of type '" "CPI::InterpolationType""'");
  } 
  arg4 = static_cast< CPI::InterpolationType >(val4);
  {
    try {
      result = (Real)CPI::laggedFixing((ext::shared_ptr< ZeroInflationIndex > const &)*arg1,(Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPI *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CPI", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (CPI *)new CPI();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CPI, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPI *arg1 = (CPI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CPI, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPI" "', argument " "1"" of type '" "CPI *""'"); 
  }
  arg1 = reinterpret_cast< CPI * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPI_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CPI, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPI_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_InflationCoupon_fixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationCoupon const > tempshared1 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationCoupon_fixingDate" "', argument " "1"" of type '" "InflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationCoupon const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationCoupon_fixingDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationCoupon const > tempshared1 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationCoupon_fixingDays" "', argument " "1"" of type '" "InflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Integer)((InflationCoupon const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationCoupon_observationLag(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationCoupon const > tempshared1 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Period result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationCoupon_observationLag" "', argument " "1"" of type '" "InflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationCoupon const *)arg1)->observationLag();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Period(result)), SWIGTYPE_p_Period, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationCoupon_indexFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationCoupon const > tempshared1 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationCoupon_indexFixing" "', argument " "1"" of type '" "InflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((InflationCoupon const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InflationCoupon_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationCoupon const > tempshared1 ;
  ext::shared_ptr< InflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< InflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflationCoupon_index" "', argument " "1"" of type '" "InflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InflationCoupon const *)arg1)->index();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InflationIndex > *smartresult = result ? new ext::shared_ptr<  InflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InflationCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InflationCoupon *arg1 = (InflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InflationCoupon > tempshared1 ;
  ext::shared_ptr< InflationCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InflationCoupon" "', argument " "1"" of type '" "InflationCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InflationCoupon > * >(argp1);
      arg1 = const_cast< InflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InflationCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_as_inflation_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< InflationCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_inflation_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_inflation_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InflationCoupon > *smartresult = result ? new ext::shared_ptr<  InflationCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InflationCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICouponPricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CPICouponPricer", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (CPICouponPricer *)new CPICouponPricer();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICouponPricer > *smartresult = result ? new ext::shared_ptr<  CPICouponPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICouponPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CPICouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICouponPricer *arg1 = (CPICouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICouponPricer > tempshared1 ;
  ext::shared_ptr< CPICouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPICouponPricer" "', argument " "1"" of type '" "CPICouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPICouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPICouponPricer > * >(argp1);
      arg1 = const_cast< CPICouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPICouponPricer > * >(argp1);
      arg1 = const_cast< CPICouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPICouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CPICouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPICouponPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  Date *arg13 = 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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  Date *arg13 = 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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11,(Date const &)*arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Date *arg11 = 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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  arg14 = reinterpret_cast< Date * >(argp14);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Date *arg12 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  Date *arg14 = 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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  arg14 = reinterpret_cast< Date * >(argp14);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  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 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 0 ;
  Date *arg14 = 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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  arg14 = reinterpret_cast< Date * >(argp14);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 0 ;
  Date *arg13 = 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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  Date *arg12 = 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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Spread arg11 ;
  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 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Spread""'");
  } 
  arg11 = static_cast< Spread >(val11);
  {
    try {
      result = (CPICoupon *)new CPICoupon((Date const &)*arg1,(Date const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,(Period const &)*arg7,arg8,(DayCounter const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  Date *arg15 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Spread""'");
  } 
  arg12 = static_cast< Spread >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  arg14 = reinterpret_cast< Date * >(argp14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CPICoupon" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12,(Date const &)*arg13,(Date const &)*arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Spread""'");
  } 
  arg12 = static_cast< Spread >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  arg14 = reinterpret_cast< Date * >(argp14);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12,(Date const &)*arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_22(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  Date *arg13 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Spread""'");
  } 
  arg12 = static_cast< Spread >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon__SWIG_23(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Date *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  CPI::InterpolationType arg9 ;
  DayCounter *arg10 = 0 ;
  Real arg11 ;
  Spread arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  CPICoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICoupon" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICoupon" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CPICoupon" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICoupon" "', argument " "9"" of type '" "CPI::InterpolationType""'");
  } 
  arg9 = static_cast< CPI::InterpolationType >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICoupon" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPICoupon" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CPICoupon" "', argument " "12"" of type '" "Spread""'");
  } 
  arg12 = static_cast< Spread >(val12);
  {
    try {
      result = (CPICoupon *)new CPICoupon(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Date const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICoupon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CPICoupon", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_CPICoupon__SWIG_7(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_CPICoupon__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_CPICoupon__SWIG_6(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_CPICoupon__SWIG_19(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_CPICoupon__SWIG_11(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_CPICoupon__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_CPICoupon__SWIG_15(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CPICoupon__SWIG_5(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CPICoupon__SWIG_18(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CPICoupon__SWIG_10(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_CPICoupon__SWIG_23(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CPICoupon__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CPICoupon__SWIG_14(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CPICoupon__SWIG_4(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CPICoupon__SWIG_17(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CPICoupon__SWIG_9(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CPICoupon__SWIG_22(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CPICoupon__SWIG_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CPICoupon__SWIG_13(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_CPICoupon__SWIG_16(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_CPICoupon__SWIG_8(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_CPICoupon__SWIG_21(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_CPICoupon__SWIG_12(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_CPICoupon__SWIG_20(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CPICoupon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &)\n"
    "    CPICoupon::CPICoupon(Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread,Date const &)\n"
    "    CPICoupon::CPICoupon(Real,Date const &,Date const &,Real,Date const &,Date const &,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,DayCounter const &,Real,Spread)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CPICoupon_fixedRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_fixedRate" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->fixedRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_spread" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)((CPICoupon const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_adjustedIndexGrowth(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_adjustedIndexGrowth" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->adjustedIndexGrowth();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_indexFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_indexFixing" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->indexFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_indexRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CPICoupon_indexRatio", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_indexRatio" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPICoupon_indexRatio" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPICoupon_indexRatio" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Real)((CPICoupon const *)arg1)->indexRatio(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_baseCPI(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_baseCPI" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CPICoupon const *)arg1)->baseCPI();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_baseDate" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CPICoupon const *)arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_observationInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  CPI::InterpolationType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_observationInterpolation" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (CPI::InterpolationType)((CPICoupon const *)arg1)->observationInterpolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_cpiIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon const > tempshared1 ;
  ext::shared_ptr< CPICoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_cpiIndex" "', argument " "1"" of type '" "CPICoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CPICoupon const *)arg1)->cpiIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICoupon_setPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  ext::shared_ptr< CPICouponPricer > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon > tempshared1 ;
  ext::shared_ptr< CPICoupon > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< CPICouponPricer > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CPICoupon_setPricer", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICoupon_setPricer" "', argument " "1"" of type '" "CPICoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CPICouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPICoupon_setPricer" "', argument " "2"" of type '" "ext::shared_ptr< CPICouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< CPICouponPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< CPICouponPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< CPICouponPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setPricer((ext::shared_ptr< CPICouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CPICoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICoupon *arg1 = (CPICoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICoupon > tempshared1 ;
  ext::shared_ptr< CPICoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPICoupon" "', argument " "1"" of type '" "CPICoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPICoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPICoupon > * >(argp1);
      arg1 = const_cast< CPICoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPICoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPICoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_cpi_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CPICoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_cpi_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_cpi_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICoupon > *smartresult = result ? new ext::shared_ptr<  CPICoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICashFlow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Date *arg8 = 0 ;
  bool arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  CPICashFlow *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICashFlow" "', argument " "2"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICashFlow" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CPICashFlow" "', argument " "7"" of type '" "CPI::InterpolationType""'");
  } 
  arg7 = static_cast< CPI::InterpolationType >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICashFlow" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CPICashFlow" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (CPICashFlow *)new CPICashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Period const &)*arg6,arg7,(Date const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICashFlow > *smartresult = result ? new ext::shared_ptr<  CPICashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICashFlow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Date *arg8 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  CPICashFlow *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPICashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CPICashFlow" "', argument " "2"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CPICashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPICashFlow" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPICashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPICashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CPICashFlow" "', argument " "7"" of type '" "CPI::InterpolationType""'");
  } 
  arg7 = static_cast< CPI::InterpolationType >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPICashFlow" "', argument " "8"" of type '" "Date const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPICashFlow" "', argument " "8"" of type '" "Date const &""'"); 
  }
  arg8 = reinterpret_cast< Date * >(argp8);
  {
    try {
      result = (CPICashFlow *)new CPICashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,(Date const &)*arg3,arg4,(Date const &)*arg5,(Period const &)*arg6,arg7,(Date const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICashFlow > *smartresult = result ? new ext::shared_ptr<  CPICashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPICashFlow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CPICashFlow", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_CPICashFlow__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CPICashFlow__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CPICashFlow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CPICashFlow::CPICashFlow(Real,ext::shared_ptr< ZeroInflationIndex > const &,Date const &,Real,Date const &,Period const &,CPI::InterpolationType,Date const &,bool)\n"
    "    CPICashFlow::CPICashFlow(Real,ext::shared_ptr< ZeroInflationIndex > const &,Date const &,Real,Date const &,Period const &,CPI::InterpolationType,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CPICashFlow_interpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICashFlow *arg1 = (CPICashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICashFlow const > tempshared1 ;
  ext::shared_ptr< CPICashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  CPI::InterpolationType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICashFlow_interpolation" "', argument " "1"" of type '" "CPICashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICashFlow > * >(argp1);
      arg1 = const_cast< CPICashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICashFlow > * >(argp1);
      arg1 = const_cast< CPICashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (CPI::InterpolationType)((CPICashFlow const *)arg1)->interpolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPICashFlow_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICashFlow *arg1 = (CPICashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICashFlow const > tempshared1 ;
  ext::shared_ptr< CPICashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPICashFlow_frequency" "', argument " "1"" of type '" "CPICashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CPICashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CPICashFlow > * >(argp1);
      arg1 = const_cast< CPICashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CPICashFlow > * >(argp1);
      arg1 = const_cast< CPICashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)((CPICashFlow const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CPICashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPICashFlow *arg1 = (CPICashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPICashFlow > tempshared1 ;
  ext::shared_ptr< CPICashFlow > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPICashFlow" "', argument " "1"" of type '" "CPICashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPICashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPICashFlow > * >(argp1);
      arg1 = const_cast< CPICashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPICashFlow > * >(argp1);
      arg1 = const_cast< CPICashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPICashFlow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPICashFlow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_cpi_cashflow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CPICashFlow > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_cpi_cashflow" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_cpi_cashflow((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPICashFlow > *smartresult = result ? new ext::shared_ptr<  CPICashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPICashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPILeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  Schedule *arg2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg3 = 0 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  DayCounter const &arg6_defvalue = DayCounter() ;
  DayCounter *arg6 = (DayCounter *) &arg6_defvalue ;
  BusinessDayConvention arg7 = (BusinessDayConvention) (BusinessDayConvention)Following ;
  std::vector< Real,std::allocator< Real > > const &arg8_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg8 = (std::vector< Real,std::allocator< Real > > *) &arg8_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg9_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg9 = (std::vector< Spread,std::allocator< Spread > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg11_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg11 = (std::vector< Rate,std::allocator< Rate > > *) &arg11_defvalue ;
  Period const &arg12_defvalue = Period() ;
  Period *arg12 = (Period *) &arg12_defvalue ;
  Calendar const &arg13_defvalue = Calendar() ;
  Calendar *arg13 = (Calendar *) &arg13_defvalue ;
  BusinessDayConvention arg14 = (BusinessDayConvention) Unadjusted ;
  bool arg15 = (bool) false ;
  Calendar const &arg16_defvalue = Calendar() ;
  Calendar *arg16 = (Calendar *) &arg16_defvalue ;
  bool arg17 = (bool) true ;
  CPI::InterpolationType arg18 = (CPI::InterpolationType) CPI::AsIndex ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  char * kwnames[] = {
    (char *)"nominals",  (char *)"schedule",  (char *)"index",  (char *)"baseCPI",  (char *)"observationLag",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixedRates",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  (char *)"paymentCalendar",  (char *)"growthOnly",  (char *)"observationInterpolation",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOOOOOOO:CPILeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPILeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CPILeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "2"" of type '" "Schedule const &""'"); 
  }
  arg2 = reinterpret_cast< Schedule * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CPILeg" "', argument " "3"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CPILeg" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CPILeg" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CPILeg" "', argument " "6"" of type '" "DayCounter const &""'"); 
    }
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "6"" of type '" "DayCounter const &""'"); 
    }
    arg6 = reinterpret_cast< DayCounter * >(argp6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CPILeg" "', argument " "7"" of type '" "BusinessDayConvention""'");
    } 
    arg7 = static_cast< BusinessDayConvention >(val7);
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CPILeg" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CPILeg" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CPILeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res11 = swig::asptr(obj10, &ptr);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CPILeg" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg11 = ptr;
    }
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "CPILeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "12"" of type '" "Period const &""'"); 
    }
    arg12 = reinterpret_cast< Period * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "CPILeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    arg13 = reinterpret_cast< Calendar * >(argp13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "CPILeg" "', argument " "14"" of type '" "BusinessDayConvention""'");
    } 
    arg14 = static_cast< BusinessDayConvention >(val14);
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_bool(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "CPILeg" "', argument " "15"" of type '" "bool""'");
    } 
    arg15 = static_cast< bool >(val15);
  }
  if (obj15) {
    res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "CPILeg" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    if (!argp16) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CPILeg" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    arg16 = reinterpret_cast< Calendar * >(argp16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_bool(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "CPILeg" "', argument " "17"" of type '" "bool""'");
    } 
    arg17 = static_cast< bool >(val17);
  }
  if (obj17) {
    ecode18 = SWIG_AsVal_int(obj17, &val18);
    if (!SWIG_IsOK(ecode18)) {
      SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "CPILeg" "', argument " "18"" of type '" "CPI::InterpolationType""'");
    } 
    arg18 = static_cast< CPI::InterpolationType >(val18);
  }
  {
    try {
      result = _CPILeg((std::vector< double,std::allocator< double > > const &)*arg1,(Schedule const &)*arg2,(ext::shared_ptr< ZeroInflationIndex > const &)*arg3,arg4,(Period const &)*arg5,(DayCounter const &)*arg6,arg7,(std::vector< double,std::allocator< double > > const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(std::vector< double,std::allocator< double > > const &)*arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15,(Calendar const &)*arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationCashFlow__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  CPI::InterpolationType arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  Date *arg7 = 0 ;
  bool arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared2 ;
  int 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 ;
  bool val8 ;
  int ecode8 = 0 ;
  ZeroInflationCashFlow *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroInflationCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationCashFlow" "', argument " "2"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroInflationCashFlow" "', argument " "3"" of type '" "CPI::InterpolationType""'");
  } 
  arg3 = static_cast< CPI::InterpolationType >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroInflationCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroInflationCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationCashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationCashFlow" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroInflationCashFlow" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (ZeroInflationCashFlow *)new ZeroInflationCashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationCashFlow > *smartresult = result ? new ext::shared_ptr<  ZeroInflationCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationCashFlow__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< ZeroInflationIndex > *arg2 = 0 ;
  CPI::InterpolationType arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Period *arg6 = 0 ;
  Date *arg7 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared2 ;
  int 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 ;
  ZeroInflationCashFlow *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroInflationCashFlow" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationCashFlow" "', argument " "2"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroInflationCashFlow" "', argument " "3"" of type '" "CPI::InterpolationType""'");
  } 
  arg3 = static_cast< CPI::InterpolationType >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroInflationCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroInflationCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationCashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "6"" of type '" "Period const &""'"); 
  }
  arg6 = reinterpret_cast< Period * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationCashFlow" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCashFlow" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (ZeroInflationCashFlow *)new ZeroInflationCashFlow(arg1,(ext::shared_ptr< ZeroInflationIndex > const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Period const &)*arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationCashFlow > *smartresult = result ? new ext::shared_ptr<  ZeroInflationCashFlow >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationCashFlow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroInflationCashFlow", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ZeroInflationCashFlow__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ZeroInflationCashFlow__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroInflationCashFlow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroInflationCashFlow::ZeroInflationCashFlow(Real,ext::shared_ptr< ZeroInflationIndex > const &,CPI::InterpolationType,Date const &,Date const &,Period const &,Date const &,bool)\n"
    "    ZeroInflationCashFlow::ZeroInflationCashFlow(Real,ext::shared_ptr< ZeroInflationIndex > const &,CPI::InterpolationType,Date const &,Date const &,Period const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCashFlow_notional(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCashFlow_notional" "', argument " "1"" of type '" "ZeroInflationCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ZeroInflationCashFlow const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCashFlow_baseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCashFlow_baseDate" "', argument " "1"" of type '" "ZeroInflationCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ZeroInflationCashFlow const *)arg1)->baseDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCashFlow_fixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCashFlow_fixingDate" "', argument " "1"" of type '" "ZeroInflationCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ZeroInflationCashFlow const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCashFlow_growthOnly(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCashFlow_growthOnly" "', argument " "1"" of type '" "ZeroInflationCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((ZeroInflationCashFlow const *)arg1)->growthOnly();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCashFlow_observationInterpolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  CPI::InterpolationType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCashFlow_observationInterpolation" "', argument " "1"" of type '" "ZeroInflationCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (CPI::InterpolationType)((ZeroInflationCashFlow const *)arg1)->observationInterpolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCashFlow_zeroInflationIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow const > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCashFlow_zeroInflationIndex" "', argument " "1"" of type '" "ZeroInflationCashFlow const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ZeroInflationCashFlow const *)arg1)->zeroInflationIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationIndex > *smartresult = result ? new ext::shared_ptr<  ZeroInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroInflationCashFlow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroInflationCashFlow *arg1 = (ZeroInflationCashFlow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroInflationCashFlow > tempshared1 ;
  ext::shared_ptr< ZeroInflationCashFlow > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroInflationCashFlow" "', argument " "1"" of type '" "ZeroInflationCashFlow *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroInflationCashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroInflationCashFlow > * >(argp1);
      arg1 = const_cast< ZeroInflationCashFlow * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroInflationCashFlow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroInflationCashFlow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_zero_inflation_cash_flow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ZeroInflationCashFlow > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_zero_inflation_cash_flow" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_zero_inflation_cash_flow((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroInflationCashFlow > *smartresult = result ? new ext::shared_ptr<  ZeroInflationCashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroInflationCashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_quote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_quote" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->quote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_latestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_latestDate" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->latestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_earliestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_earliestDate" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_maturityDate" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_latestRelevantDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_latestRelevantDate" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_pillarDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_pillarDate" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_impliedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_impliedQuote" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelper_quoteError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelper_quoteError" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BootstrapHelper< ZeroInflationTermStructure > const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< ZeroInflationTermStructure > *arg1 = (BootstrapHelper< ZeroInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroHelper" "', argument " "1"" of type '" "BootstrapHelper< ZeroInflationTermStructure > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< ZeroInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_YoYHelper_quote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_quote" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->quote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_latestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_latestDate" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->latestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_earliestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_earliestDate" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_maturityDate" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_latestRelevantDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_latestRelevantDate" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_pillarDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_pillarDate" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_impliedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_impliedQuote" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelper_quoteError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelper_quoteError" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BootstrapHelper< YoYInflationTermStructure > const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYInflationTermStructure > *arg1 = (BootstrapHelper< YoYInflationTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYHelper" "', argument " "1"" of type '" "BootstrapHelper< YoYInflationTermStructure > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYInflationTermStructure > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_YoYOptionHelper_quote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_quote" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->quote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_latestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_latestDate" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->latestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_earliestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_earliestDate" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_maturityDate" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_latestRelevantDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_latestRelevantDate" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_pillarDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_pillarDate" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_impliedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_impliedQuote" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelper_quoteError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelper_quoteError" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BootstrapHelper< YoYOptionletVolatilitySurface > const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYOptionHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BootstrapHelper< YoYOptionletVolatilitySurface > *arg1 = (BootstrapHelper< YoYOptionletVolatilitySurface > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > tempshared1 ;
  ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYOptionHelper" "', argument " "1"" of type '" "BootstrapHelper< YoYOptionletVolatilitySurface > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > * >(argp1);
      arg1 = const_cast< BootstrapHelper< YoYOptionletVolatilitySurface > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYOptionHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ZeroHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____nonzero__((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____bool__((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____len__((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZeroHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZeroHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ZeroHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__setslice__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__setslice__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ZeroHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZeroHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__delitem__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ZeroHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZeroHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__getitem__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ZeroHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ZeroHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ZeroHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::__setitem__(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > *smartresult = result ? new ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__append(arg1,(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZeroHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_ZeroHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_ZeroHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::erase(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::erase(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ZeroHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >(arg1,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ZeroHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ZeroHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ZeroHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ZeroHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::vector()\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZeroHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *) &((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *) &((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<ZeroInflationTermStructure> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZeroHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ZeroHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::resize(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::resize(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZeroHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ZeroHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZeroHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZeroHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_ZeroInflationTermStructure_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ZeroHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ZeroHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ZeroHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZeroHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::insert(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::insert(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ZeroHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZeroHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_YoYHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____nonzero__((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____bool__((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____len__((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__setslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__setslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_YoYHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__delitem__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_YoYHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__getitem__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_YoYHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::__setitem__(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > *smartresult = result ? new ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__append(arg1,(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_YoYHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_YoYHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::erase(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::erase(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_YoYHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >(arg1,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_YoYHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YoYHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YoYHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YoYHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::vector()\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *) &((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *) &((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<YoYInflationTermStructure> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::resize(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::resize(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYInflationTermStructure_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::insert(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::insert(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____nonzero__((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____bool__((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____len__((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYOptionHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__setslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__setslice__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *)std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_YoYOptionHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYOptionHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__delitem__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_YoYOptionHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYOptionHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__getitem__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_YoYOptionHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYOptionHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYOptionHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::__setitem__(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > *smartresult = result ? new ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__append(arg1,(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYOptionHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYOptionHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYOptionHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_YoYOptionHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_YoYOptionHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::erase(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::erase(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg1 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYOptionHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYOptionHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *)new std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >(arg1,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYOptionHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYOptionHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_YoYOptionHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_YoYOptionHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YoYOptionHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_YoYOptionHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYOptionHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::vector()\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::vector(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *) &((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *) &((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> > *smartresult = *result ? new ext::shared_ptr<  BootstrapHelper<YoYOptionletVolatilitySurface> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_YoYOptionHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYOptionHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::resize(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::resize(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg3 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "YoYOptionHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYOptionHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "YoYOptionHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BootstrapHelper_Sl_YoYOptionletVolatilitySurface_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYOptionHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_YoYOptionHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYOptionHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::insert(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::insert(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type,std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYOptionHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYOptionHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *arg1 = (std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYOptionHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYOptionHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_std__allocatorT_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYOptionHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZeroCouponInflationSwapHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Date *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg7 = 0 ;
  CPI::InterpolationType arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared7 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject *swig_obj[9] ;
  ZeroCouponInflationSwapHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZeroCouponInflationSwapHelper", 9, 9, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "7"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "8"" of type '" "CPI::InterpolationType""'");
  } 
  arg8 = static_cast< CPI::InterpolationType >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwapHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  {
    try {
      result = (ZeroCouponInflationSwapHelper *)new ZeroCouponInflationSwapHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< ZeroInflationIndex > const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponInflationSwapHelper > *smartresult = result ? new ext::shared_ptr<  ZeroCouponInflationSwapHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroCouponInflationSwapHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwapHelper *arg1 = (ZeroCouponInflationSwapHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwapHelper > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwapHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroCouponInflationSwapHelper" "', argument " "1"" of type '" "ZeroCouponInflationSwapHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwapHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwapHelper > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwapHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwapHelper > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwapHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroCouponInflationSwapHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroCouponInflationSwapHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YearOnYearInflationSwapHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Date *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 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 val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[8] ;
  YearOnYearInflationSwapHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YearOnYearInflationSwapHelper", 8, 8, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "7"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwapHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    try {
      result = (YearOnYearInflationSwapHelper *)new YearOnYearInflationSwapHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Date const &)*arg3,(Calendar const &)*arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< YoYInflationIndex > const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YearOnYearInflationSwapHelper > *smartresult = result ? new ext::shared_ptr<  YearOnYearInflationSwapHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YearOnYearInflationSwapHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwapHelper *arg1 = (YearOnYearInflationSwapHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwapHelper > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwapHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YearOnYearInflationSwapHelper" "', argument " "1"" of type '" "YearOnYearInflationSwapHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwapHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwapHelper > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwapHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwapHelper > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwapHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YearOnYearInflationSwapHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YearOnYearInflationSwapHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseZeroInflation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  Rate arg6 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *arg7 = 0 ;
  Real arg8 ;
  Linear *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseZeroInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseZeroInflation" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseZeroInflation" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseZeroInflation" "', argument " "7"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "7"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    arg7 = ptr;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_PiecewiseZeroInflation" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_PiecewiseZeroInflation" "', argument " "9"" of type '" "Linear const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "9"" of type '" "Linear const &""'"); 
  }
  arg9 = reinterpret_cast< Linear * >(argp9);
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)*arg7,arg8,(Linear const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroInflation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  Rate arg6 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *arg7 = 0 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  double val8 ;
  int ecode8 = 0 ;
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseZeroInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseZeroInflation" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseZeroInflation" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseZeroInflation" "', argument " "7"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "7"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    arg7 = ptr;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_PiecewiseZeroInflation" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroInflation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  Rate arg6 ;
  std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  PiecewiseZeroInflationCurve< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseZeroInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseZeroInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseZeroInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseZeroInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseZeroInflation" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseZeroInflation" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseZeroInflation" "', argument " "7"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseZeroInflation" "', argument " "7"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      result = (PiecewiseZeroInflationCurve< Linear > *)new PiecewiseZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseZeroInflation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseZeroInflation", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseZeroInflation__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_PiecewiseZeroInflation__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_PiecewiseZeroInflation__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseZeroInflation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseZeroInflationCurve< Linear >::PiecewiseZeroInflationCurve(Date const &,Calendar const &,DayCounter const &,Period const &,Frequency,Rate,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &,Real,Linear const &)\n"
    "    PiecewiseZeroInflationCurve< Linear >::PiecewiseZeroInflationCurve(Date const &,Calendar const &,DayCounter const &,Period const &,Frequency,Rate,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &,Real)\n"
    "    PiecewiseZeroInflationCurve< Linear >::PiecewiseZeroInflationCurve(Date const &,Calendar const &,DayCounter const &,Period const &,Frequency,Rate,std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseZeroInflation_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseZeroInflation_dates" "', argument " "1"" of type '" "PiecewiseZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseZeroInflationCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseZeroInflation_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseZeroInflation_times" "', argument " "1"" of type '" "PiecewiseZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseZeroInflationCurve< Linear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseZeroInflation_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseZeroInflation_nodes" "', argument " "1"" of type '" "PiecewiseZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseZeroInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseZeroInflation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseZeroInflationCurve< Linear > *arg1 = (PiecewiseZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > tempshared1 ;
  ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseZeroInflation" "', argument " "1"" of type '" "PiecewiseZeroInflationCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseZeroInflation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseZeroInflation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseYoYInflation(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  Rate arg7 ;
  std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *arg8 = 0 ;
  Real arg9 = (Real) 1.0e-12 ;
  Linear const &arg10_defvalue = Linear() ;
  Linear *arg10 = (Linear *) &arg10_defvalue ;
  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 val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"referenceDate",  (char *)"calendar",  (char *)"dayCounter",  (char *)"lag",  (char *)"frequency",  (char *)"indexIsInterpolated",  (char *)"baseRate",  (char *)"instruments",  (char *)"accuracy",  (char *)"i",  NULL 
  };
  PiecewiseYoYInflationCurve< Linear > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO|OO:new_PiecewiseYoYInflation", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseYoYInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseYoYInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseYoYInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseYoYInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PiecewiseYoYInflation" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PiecewiseYoYInflation" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PiecewiseYoYInflation" "', argument " "7"" of type '" "Rate""'");
  } 
  arg7 = static_cast< Rate >(val7);
  {
    std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *ptr = (std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > *)0;
    res8 = swig::asptr(obj7, &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseYoYInflation" "', argument " "8"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "8"" of type '" "std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &""'"); 
    }
    arg8 = ptr;
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_double(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_PiecewiseYoYInflation" "', argument " "9"" of type '" "Real""'");
    } 
    arg9 = static_cast< Real >(val9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Linear,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_PiecewiseYoYInflation" "', argument " "10"" of type '" "Linear const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseYoYInflation" "', argument " "10"" of type '" "Linear const &""'"); 
    }
    arg10 = reinterpret_cast< Linear * >(argp10);
  }
  {
    try {
      result = (PiecewiseYoYInflationCurve< Linear > *)new PiecewiseYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,arg7,(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >,std::allocator< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > > > const &)*arg8,arg9,(Linear const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseYoYInflation_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseYoYInflation_dates" "', argument " "1"" of type '" "PiecewiseYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseYoYInflationCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseYoYInflation_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseYoYInflation_times" "', argument " "1"" of type '" "PiecewiseYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseYoYInflationCurve< Linear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseYoYInflation_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseYoYInflation_nodes" "', argument " "1"" of type '" "PiecewiseYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseYoYInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseYoYInflation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseYoYInflationCurve< Linear > *arg1 = (PiecewiseYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > tempshared1 ;
  ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseYoYInflation" "', argument " "1"" of type '" "PiecewiseYoYInflationCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< PiecewiseYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseYoYInflation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseYoYInflation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatePair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< Date,Date > *)new std::pair< Date,Date >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_Date_Date_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatePair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date arg1 ;
  Date arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::pair< Date,Date > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatePair" "', argument " "1"" of type '" "Date""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatePair" "', argument " "1"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DatePair" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatePair" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (std::pair< Date,Date > *)new std::pair< Date,Date >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_Date_Date_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatePair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< Date,Date > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< Date,Date > *ptr = (std::pair< Date,Date > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatePair" "', argument " "1"" of type '" "std::pair< Date,Date > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatePair" "', argument " "1"" of type '" "std::pair< Date,Date > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< Date,Date > *)new std::pair< Date,Date >((std::pair< Date,Date > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_Date_Date_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatePair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DatePair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DatePair__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< Date,Date >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DatePair__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DatePair__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DatePair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< Date,Date >::pair()\n"
    "    std::pair< Date,Date >::pair(Date,Date)\n"
    "    std::pair< Date,Date >::pair(std::pair< Date,Date > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DatePair_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DatePair_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePair_first_set" "', argument " "1"" of type '" "std::pair< Date,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DatePair_first_set" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatePair_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePair_first_get" "', argument " "1"" of type '" "std::pair< Date,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,Date > * >(argp1);
  result = (Date *)& ((arg1)->first);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatePair_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  Date *arg2 = (Date *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DatePair_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePair_second_set" "', argument " "1"" of type '" "std::pair< Date,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Date, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DatePair_second_set" "', argument " "2"" of type '" "Date *""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DatePair_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_Date_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DatePair_second_get" "', argument " "1"" of type '" "std::pair< Date,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,Date > * >(argp1);
  result = (Date *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DatePair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< Date,Date > *arg1 = (std::pair< Date,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_Date_Date_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatePair" "', argument " "1"" of type '" "std::pair< Date,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< Date,Date > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatePair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_Date_Date_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatePair_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_inflationPeriod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Frequency arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::pair< Date,Date > result;
  
  if (!SWIG_Python_UnpackTuple(args, "inflationPeriod", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inflationPeriod" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inflationPeriod" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "inflationPeriod" "', argument " "2"" of type '" "Frequency""'");
  } 
  arg2 = static_cast< Frequency >(val2);
  {
    try {
      result = inflationPeriod((Date const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< Date,Date > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_inflationYearFraction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Frequency arg1 ;
  bool arg2 ;
  DayCounter *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "inflationYearFraction", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "inflationYearFraction" "', argument " "1"" of type '" "Frequency""'");
  } 
  arg1 = static_cast< Frequency >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "inflationYearFraction" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "inflationYearFraction" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inflationYearFraction" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "inflationYearFraction" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inflationYearFraction" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "inflationYearFraction" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inflationYearFraction" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Time)inflationYearFraction(arg1,arg2,(DayCounter const &)*arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_inflationBaseDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "inflationBaseDate", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inflationBaseDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inflationBaseDate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inflationBaseDate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inflationBaseDate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "inflationBaseDate" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "inflationBaseDate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = inflationBaseDate((Date const &)*arg1,(Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCouponPricer *arg1 = (YoYInflationCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCouponPricer > tempshared1 ;
  ext::shared_ptr< YoYInflationCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCouponPricer" "', argument " "1"" of type '" "YoYInflationCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< YoYInflationCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< YoYInflationCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_setCouponPricer__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Leg *arg1 = 0 ;
  ext::shared_ptr< YoYInflationCouponPricer > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YoYInflationCouponPricer > tempshared2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setCouponPricer" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "setCouponPricer" "', argument " "1"" of type '" "Leg const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCouponPricer_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setCouponPricer" "', argument " "2"" of type '" "ext::shared_ptr< YoYInflationCouponPricer > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YoYInflationCouponPricer > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationCouponPricer > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YoYInflationCouponPricer > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      setCouponPricer((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(ext::shared_ptr< YoYInflationCouponPricer > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_setCouponPricer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "setCouponPricer", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FloatingRateCouponPricer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_setCouponPricer__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_EquityCashFlowPricer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_setCouponPricer__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCouponPricer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_setCouponPricer__SWIG_2(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'setCouponPricer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    setCouponPricer(Leg const &,ext::shared_ptr< FloatingRateCouponPricer > const &)\n"
    "    setCouponPricer(Leg const &,ext::shared_ptr< EquityCashFlowPricer > const &)\n"
    "    setCouponPricer(Leg const &,ext::shared_ptr< YoYInflationCouponPricer > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCoupon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Date *arg11 = 0 ;
  Date *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  YoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_YoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YoYInflationCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_YoYInflationCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "12"" of type '" "Date const &""'"); 
  }
  arg12 = reinterpret_cast< Date * >(argp12);
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,(Date const &)*arg11,(Date const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCoupon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Date *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  YoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_YoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YoYInflationCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCoupon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  YoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_YoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCoupon__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  YoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCoupon__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  YoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (YoYInflationCoupon *)new YoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  YoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCoupon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYInflationCoupon", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_YoYInflationCoupon__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_YoYInflationCoupon__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_YoYInflationCoupon__SWIG_2(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_YoYInflationCoupon__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_YoYInflationCoupon__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYInflationCoupon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYInflationCoupon::YoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread,Date const &,Date const &)\n"
    "    YoYInflationCoupon::YoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread,Date const &)\n"
    "    YoYInflationCoupon::YoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread)\n"
    "    YoYInflationCoupon::YoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real)\n"
    "    YoYInflationCoupon::YoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationCoupon_gearing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCoupon_gearing" "', argument " "1"" of type '" "YoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((YoYInflationCoupon const *)arg1)->gearing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCoupon_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCoupon_spread" "', argument " "1"" of type '" "YoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)((YoYInflationCoupon const *)arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCoupon_adjustedFixing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCoupon_adjustedFixing" "', argument " "1"" of type '" "YoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((YoYInflationCoupon const *)arg1)->adjustedFixing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCoupon_yoyIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< YoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYInflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCoupon_yoyIndex" "', argument " "1"" of type '" "YoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYInflationCoupon const *)arg1)->yoyIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCoupon *arg1 = (YoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCoupon > tempshared1 ;
  ext::shared_ptr< YoYInflationCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCoupon" "', argument " "1"" of type '" "YoYInflationCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCoupon > * >(argp1);
      arg1 = const_cast< YoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_yoy_inflation_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYInflationCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_yoy_inflation_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_yoy_inflation_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  YoYInflationCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  Rate arg12 ;
  Date *arg13 = 0 ;
  Date *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "12"" of type '" "Rate""'");
  } 
  arg12 = static_cast< Rate >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "14"" of type '" "Date const &""'"); 
  }
  arg14 = reinterpret_cast< Date * >(argp14);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,arg12,(Date const &)*arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  Rate arg12 ;
  Date *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "12"" of type '" "Rate""'");
  } 
  arg12 = static_cast< Rate >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  Rate arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "12"" of type '" "Rate""'");
  } 
  arg12 = static_cast< Rate >(val12);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  Rate arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Spread arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Natural arg5 ;
  ext::shared_ptr< YoYInflationIndex > *arg6 = 0 ;
  Period *arg7 = 0 ;
  DayCounter *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  CappedFlooredYoYInflationCoupon *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "6"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "7"" of type '" "Period const &""'"); 
  }
  arg7 = reinterpret_cast< Period * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CappedFlooredYoYInflationCoupon" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (CappedFlooredYoYInflationCoupon *)new CappedFlooredYoYInflationCoupon((Date const &)*arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< YoYInflationIndex > const &)*arg6,(Period const &)*arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CappedFlooredYoYInflationCoupon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[15] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CappedFlooredYoYInflationCoupon", 0, 14, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_6(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_5(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_4(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_3(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_2(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_1(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_CappedFlooredYoYInflationCoupon__SWIG_0(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CappedFlooredYoYInflationCoupon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread,Rate const,Rate const,Date const &,Date const &)\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread,Rate const,Rate const,Date const &)\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread,Rate const,Rate const)\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread,Rate const)\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real,Spread)\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &,Real)\n"
    "    CappedFlooredYoYInflationCoupon::CappedFlooredYoYInflationCoupon(Date const &,Real,Date const &,Date const &,Natural,ext::shared_ptr< YoYInflationIndex > const &,Period const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_rate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_rate" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->rate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_cap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_cap" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->cap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_floor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_floor" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->floor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_effectiveCap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_effectiveCap" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->effectiveCap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_effectiveFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_effectiveFloor" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->effectiveFloor();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_underlyingRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_underlyingRate" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CappedFlooredYoYInflationCoupon const *)arg1)->underlyingRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_isCapped(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_isCapped" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CappedFlooredYoYInflationCoupon const *)arg1)->isCapped();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CappedFlooredYoYInflationCoupon_isFloored(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CappedFlooredYoYInflationCoupon_isFloored" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CappedFlooredYoYInflationCoupon const *)arg1)->isFloored();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CappedFlooredYoYInflationCoupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CappedFlooredYoYInflationCoupon *arg1 = (CappedFlooredYoYInflationCoupon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon > tempshared1 ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CappedFlooredYoYInflationCoupon" "', argument " "1"" of type '" "CappedFlooredYoYInflationCoupon *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CappedFlooredYoYInflationCoupon > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CappedFlooredYoYInflationCoupon > * >(argp1);
      arg1 = const_cast< CappedFlooredYoYInflationCoupon * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CappedFlooredYoYInflationCoupon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CappedFlooredYoYInflationCoupon_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_capped_floored_yoy_inflation_coupon(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CashFlow > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CashFlow > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CappedFlooredYoYInflationCoupon > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CashFlow_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_capped_floored_yoy_inflation_coupon" "', argument " "1"" of type '" "ext::shared_ptr< CashFlow > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CashFlow > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_capped_floored_yoy_inflation_coupon((ext::shared_ptr< CashFlow > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CappedFlooredYoYInflationCoupon > *smartresult = result ? new ext::shared_ptr<  CappedFlooredYoYInflationCoupon >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_yoyInflationLeg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Schedule *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Period *arg4 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 = (BusinessDayConvention) Following ;
  Natural arg8 = (Natural) 0 ;
  std::vector< Real,std::allocator< Real > > const &arg9_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg9 = (std::vector< Real,std::allocator< Real > > *) &arg9_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg10_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = (std::vector< Spread,std::allocator< Spread > > *) &arg10_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg11_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg11 = (std::vector< Rate,std::allocator< Rate > > *) &arg11_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg12_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg12 = (std::vector< Rate,std::allocator< Rate > > *) &arg12_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  int res12 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  char * kwnames[] = {
    (char *)"schedule",  (char *)"calendar",  (char *)"index",  (char *)"observationLag",  (char *)"notionals",  (char *)"paymentDayCounter",  (char *)"paymentAdjustment",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  NULL 
  };
  Leg result;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|OOOOOO:yoyInflationLeg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "yoyInflationLeg" "', argument " "1"" of type '" "Schedule const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "1"" of type '" "Schedule const &""'"); 
  }
  arg1 = reinterpret_cast< Schedule * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "yoyInflationLeg" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "yoyInflationLeg" "', argument " "3"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "yoyInflationLeg" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(obj4, &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "yoyInflationLeg" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "yoyInflationLeg" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "yoyInflationLeg" "', argument " "7"" of type '" "BusinessDayConvention""'");
    } 
    arg7 = static_cast< BusinessDayConvention >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "yoyInflationLeg" "', argument " "8"" of type '" "Natural""'");
    } 
    arg8 = static_cast< Natural >(val8);
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "yoyInflationLeg" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "yoyInflationLeg" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res11 = swig::asptr(obj10, &ptr);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "yoyInflationLeg" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg11 = ptr;
    }
  }
  if (obj11) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res12 = swig::asptr(obj11, &ptr);
      if (!SWIG_IsOK(res12)) {
        SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "yoyInflationLeg" "', argument " "12"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "yoyInflationLeg" "', argument " "12"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg12 = ptr;
    }
  }
  {
    try {
      result = _yoyInflationLeg((Schedule const &)*arg1,(Calendar const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,(Period const &)*arg4,(std::vector< double,std::allocator< double > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(std::vector< double,std::allocator< double > > const &)*arg11,(std::vector< double,std::allocator< double > > const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackYoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  BlackYoYInflationCouponPricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackYoYInflationCouponPricer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackYoYInflationCouponPricer" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackYoYInflationCouponPricer" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackYoYInflationCouponPricer" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackYoYInflationCouponPricer" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (BlackYoYInflationCouponPricer *)new BlackYoYInflationCouponPricer((Handle< YoYOptionletVolatilitySurface > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackYoYInflationCouponPricer > *smartresult = result ? new ext::shared_ptr<  BlackYoYInflationCouponPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackYoYInflationCouponPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackYoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackYoYInflationCouponPricer *arg1 = (BlackYoYInflationCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackYoYInflationCouponPricer > tempshared1 ;
  ext::shared_ptr< BlackYoYInflationCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackYoYInflationCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackYoYInflationCouponPricer" "', argument " "1"" of type '" "BlackYoYInflationCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackYoYInflationCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackYoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< BlackYoYInflationCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackYoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< BlackYoYInflationCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackYoYInflationCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackYoYInflationCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackYoYInflationCouponPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UnitDisplacedBlackYoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  UnitDisplacedBlackYoYInflationCouponPricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_UnitDisplacedBlackYoYInflationCouponPricer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnitDisplacedBlackYoYInflationCouponPricer" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnitDisplacedBlackYoYInflationCouponPricer" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UnitDisplacedBlackYoYInflationCouponPricer" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnitDisplacedBlackYoYInflationCouponPricer" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (UnitDisplacedBlackYoYInflationCouponPricer *)new UnitDisplacedBlackYoYInflationCouponPricer((Handle< YoYOptionletVolatilitySurface > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer > *smartresult = result ? new ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UnitDisplacedBlackYoYInflationCouponPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UnitDisplacedBlackYoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UnitDisplacedBlackYoYInflationCouponPricer *arg1 = (UnitDisplacedBlackYoYInflationCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UnitDisplacedBlackYoYInflationCouponPricer > tempshared1 ;
  ext::shared_ptr< UnitDisplacedBlackYoYInflationCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UnitDisplacedBlackYoYInflationCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitDisplacedBlackYoYInflationCouponPricer" "', argument " "1"" of type '" "UnitDisplacedBlackYoYInflationCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< UnitDisplacedBlackYoYInflationCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UnitDisplacedBlackYoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< UnitDisplacedBlackYoYInflationCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnitDisplacedBlackYoYInflationCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UnitDisplacedBlackYoYInflationCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UnitDisplacedBlackYoYInflationCouponPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BachelierYoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YoYOptionletVolatilitySurface > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  BachelierYoYInflationCouponPricer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BachelierYoYInflationCouponPricer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BachelierYoYInflationCouponPricer" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierYoYInflationCouponPricer" "', argument " "1"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BachelierYoYInflationCouponPricer" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierYoYInflationCouponPricer" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (BachelierYoYInflationCouponPricer *)new BachelierYoYInflationCouponPricer((Handle< YoYOptionletVolatilitySurface > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BachelierYoYInflationCouponPricer > *smartresult = result ? new ext::shared_ptr<  BachelierYoYInflationCouponPricer >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BachelierYoYInflationCouponPricer_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BachelierYoYInflationCouponPricer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BachelierYoYInflationCouponPricer *arg1 = (BachelierYoYInflationCouponPricer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BachelierYoYInflationCouponPricer > tempshared1 ;
  ext::shared_ptr< BachelierYoYInflationCouponPricer > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BachelierYoYInflationCouponPricer_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BachelierYoYInflationCouponPricer" "', argument " "1"" of type '" "BachelierYoYInflationCouponPricer *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BachelierYoYInflationCouponPricer > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BachelierYoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< BachelierYoYInflationCouponPricer * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BachelierYoYInflationCouponPricer > * >(argp1);
      arg1 = const_cast< BachelierYoYInflationCouponPricer * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BachelierYoYInflationCouponPricer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BachelierYoYInflationCouponPricer_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BachelierYoYInflationCouponPricer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZeroCouponInflationSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  bool arg12 ;
  SwigValueWrapper< Calendar > arg13 ;
  BusinessDayConvention arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponInflationSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponInflationSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCouponInflationSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponInflationSwap" "', argument " "8"" of type '" "Rate""'");
  } 
  arg8 = static_cast< Rate >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ZeroCouponInflationSwap" "', argument " "9"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "CPI::InterpolationType""'");
  } 
  arg11 = static_cast< CPI::InterpolationType >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZeroCouponInflationSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_ZeroCouponInflationSwap" "', argument " "13"" of type '" "Calendar""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "13"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ZeroCouponInflationSwap" "', argument " "14"" of type '" "BusinessDayConvention""'");
  } 
  arg14 = static_cast< BusinessDayConvention >(val14);
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > const &)*arg9,(Period const &)*arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponInflationSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponInflationSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  bool arg12 ;
  SwigValueWrapper< Calendar > arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponInflationSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponInflationSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCouponInflationSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponInflationSwap" "', argument " "8"" of type '" "Rate""'");
  } 
  arg8 = static_cast< Rate >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ZeroCouponInflationSwap" "', argument " "9"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "CPI::InterpolationType""'");
  } 
  arg11 = static_cast< CPI::InterpolationType >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZeroCouponInflationSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_ZeroCouponInflationSwap" "', argument " "13"" of type '" "Calendar""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "13"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > const &)*arg9,(Period const &)*arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponInflationSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponInflationSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  bool arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponInflationSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponInflationSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCouponInflationSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponInflationSwap" "', argument " "8"" of type '" "Rate""'");
  } 
  arg8 = static_cast< Rate >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ZeroCouponInflationSwap" "', argument " "9"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "CPI::InterpolationType""'");
  } 
  arg11 = static_cast< CPI::InterpolationType >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ZeroCouponInflationSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > const &)*arg9,(Period const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponInflationSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponInflationSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  ext::shared_ptr< ZeroInflationIndex > *arg9 = 0 ;
  Period *arg10 = 0 ;
  CPI::InterpolationType arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  ZeroCouponInflationSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponInflationSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ZeroCouponInflationSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCouponInflationSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ZeroCouponInflationSwap" "', argument " "8"" of type '" "Rate""'");
  } 
  arg8 = static_cast< Rate >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ZeroCouponInflationSwap" "', argument " "9"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponInflationSwap" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ZeroCouponInflationSwap" "', argument " "11"" of type '" "CPI::InterpolationType""'");
  } 
  arg11 = static_cast< CPI::InterpolationType >(val11);
  {
    try {
      result = (ZeroCouponInflationSwap *)new ZeroCouponInflationSwap(arg1,arg2,(Date const &)*arg3,(Date const &)*arg4,(Calendar const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,(ext::shared_ptr< ZeroInflationIndex > const &)*arg9,(Period const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponInflationSwap > *smartresult = result ? new ext::shared_ptr<  ZeroCouponInflationSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponInflationSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[15] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroCouponInflationSwap", 0, 14, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ZeroCouponInflationSwap__SWIG_3(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ZeroCouponInflationSwap__SWIG_2(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_ZeroCouponInflationSwap__SWIG_1(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ZeroCouponInflationSwap__SWIG_0(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroCouponInflationSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(Swap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,bool,Calendar,BusinessDayConvention)\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(Swap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,bool,Calendar)\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(Swap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType,bool)\n"
    "    ZeroCouponInflationSwap::ZeroCouponInflationSwap(Swap::Type,Real,Date const &,Date const &,Calendar const &,BusinessDayConvention,DayCounter const &,Rate,ext::shared_ptr< ZeroInflationIndex > const &,Period const &,CPI::InterpolationType)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_fairRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponInflationSwap_fairRate" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponInflationSwap_fixedLegNPV" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_inflationLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponInflationSwap_inflationLegNPV" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->inflationLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponInflationSwap_fixedLeg" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_inflationLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponInflationSwap_inflationLeg" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->inflationLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCouponInflationSwap_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Swap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCouponInflationSwap_type" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Swap::Type)(arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroCouponInflationSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponInflationSwap *arg1 = (ZeroCouponInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponInflationSwap > tempshared1 ;
  ext::shared_ptr< ZeroCouponInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroCouponInflationSwap" "', argument " "1"" of type '" "ZeroCouponInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponInflationSwap > * >(argp1);
      arg1 = const_cast< ZeroCouponInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroCouponInflationSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroCouponInflationSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroCouponInflationSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YearOnYearInflationSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  Spread arg9 ;
  DayCounter *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  YearOnYearInflationSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YearOnYearInflationSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YearOnYearInflationSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YearOnYearInflationSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YearOnYearInflationSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_YearOnYearInflationSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YearOnYearInflationSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YearOnYearInflationSwap" "', argument " "7"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YearOnYearInflationSwap" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YearOnYearInflationSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_YearOnYearInflationSwap" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YearOnYearInflationSwap" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  arg11 = reinterpret_cast< Calendar * >(argp11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_YearOnYearInflationSwap" "', argument " "12"" of type '" "BusinessDayConvention""'");
  } 
  arg12 = static_cast< BusinessDayConvention >(val12);
  {
    try {
      result = (YearOnYearInflationSwap *)new YearOnYearInflationSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< YoYInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,(Calendar const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YearOnYearInflationSwap > *smartresult = result ? new ext::shared_ptr<  YearOnYearInflationSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YearOnYearInflationSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  Rate arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg7 = 0 ;
  Period *arg8 = 0 ;
  Spread arg9 ;
  DayCounter *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  YearOnYearInflationSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YearOnYearInflationSwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YearOnYearInflationSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YearOnYearInflationSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YearOnYearInflationSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_YearOnYearInflationSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YearOnYearInflationSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YearOnYearInflationSwap" "', argument " "7"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YearOnYearInflationSwap" "', argument " "8"" of type '" "Period const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "8"" of type '" "Period const &""'"); 
  }
  arg8 = reinterpret_cast< Period * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YearOnYearInflationSwap" "', argument " "9"" of type '" "Spread""'");
  } 
  arg9 = static_cast< Spread >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_YearOnYearInflationSwap" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YearOnYearInflationSwap" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YearOnYearInflationSwap" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  arg11 = reinterpret_cast< Calendar * >(argp11);
  {
    try {
      result = (YearOnYearInflationSwap *)new YearOnYearInflationSwap(arg1,arg2,(Schedule const &)*arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(ext::shared_ptr< YoYInflationIndex > const &)*arg7,(Period const &)*arg8,arg9,(DayCounter const &)*arg10,(Calendar const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YearOnYearInflationSwap > *smartresult = result ? new ext::shared_ptr<  YearOnYearInflationSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YearOnYearInflationSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YearOnYearInflationSwap", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_YearOnYearInflationSwap__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_YearOnYearInflationSwap__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YearOnYearInflationSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YearOnYearInflationSwap::YearOnYearInflationSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,Schedule const &,ext::shared_ptr< YoYInflationIndex > const &,Period const &,Spread,DayCounter const &,Calendar const &,BusinessDayConvention)\n"
    "    YearOnYearInflationSwap::YearOnYearInflationSwap(Swap::Type,Real,Schedule const &,Rate,DayCounter const &,Schedule const &,ext::shared_ptr< YoYInflationIndex > const &,Period const &,Spread,DayCounter const &,Calendar const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YearOnYearInflationSwap_fairRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YearOnYearInflationSwap_fairRate" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YearOnYearInflationSwap_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YearOnYearInflationSwap_fixedLegNPV" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YearOnYearInflationSwap_yoyLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YearOnYearInflationSwap_yoyLegNPV" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->yoyLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YearOnYearInflationSwap_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YearOnYearInflationSwap_fairSpread" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YearOnYearInflationSwap_fixedLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YearOnYearInflationSwap_fixedLeg" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->fixedLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YearOnYearInflationSwap_yoyLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YearOnYearInflationSwap_yoyLeg" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->yoyLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YearOnYearInflationSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YearOnYearInflationSwap *arg1 = (YearOnYearInflationSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YearOnYearInflationSwap > tempshared1 ;
  ext::shared_ptr< YearOnYearInflationSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YearOnYearInflationSwap" "', argument " "1"" of type '" "YearOnYearInflationSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YearOnYearInflationSwap > * >(argp1);
      arg1 = const_cast< YearOnYearInflationSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YearOnYearInflationSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YearOnYearInflationSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YearOnYearInflationSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CPISwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  bool arg3 ;
  Spread arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  BusinessDayConvention *arg7 = 0 ;
  Natural arg8 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Rate arg10 ;
  Real arg11 ;
  DayCounter *arg12 = 0 ;
  Schedule *arg13 = 0 ;
  BusinessDayConvention *arg14 = 0 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg16 = 0 ;
  CPI::InterpolationType arg17 ;
  Real arg18 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 ;
  BusinessDayConvention temp7 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< IborIndex > tempshared9 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 ;
  BusinessDayConvention temp14 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared16 ;
  int val17 ;
  int ecode17 = 0 ;
  double val18 ;
  int ecode18 = 0 ;
  CPISwap *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPISwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CPISwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPISwap" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPISwap" "', argument " "4"" of type '" "Spread""'");
  } 
  arg4 = static_cast< Spread >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPISwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPISwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  ecode7 = SWIG_AsVal_int (swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CPISwap" "', argument " "7"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp7 = static_cast< BusinessDayConvention >(val7);
    arg7 = &temp7;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPISwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPISwap" "', argument " "9"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9) : &tempshared9;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPISwap" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPISwap" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPISwap" "', argument " "12"" of type '" "DayCounter const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "12"" of type '" "DayCounter const &""'"); 
  }
  arg12 = reinterpret_cast< DayCounter * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPISwap" "', argument " "13"" of type '" "Schedule const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "13"" of type '" "Schedule const &""'"); 
  }
  arg13 = reinterpret_cast< Schedule * >(argp13);
  ecode14 = SWIG_AsVal_int (swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CPISwap" "', argument " "14"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp14 = static_cast< BusinessDayConvention >(val14);
    arg14 = &temp14;
  }
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CPISwap" "', argument " "15"" of type '" "Period const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "15"" of type '" "Period const &""'"); 
  }
  arg15 = reinterpret_cast< Period * >(argp15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_CPISwap" "', argument " "16"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16) : &tempshared16;
    }
  }
  ecode17 = SWIG_AsVal_int(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_CPISwap" "', argument " "17"" of type '" "CPI::InterpolationType""'");
  } 
  arg17 = static_cast< CPI::InterpolationType >(val17);
  ecode18 = SWIG_AsVal_double(swig_obj[17], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_CPISwap" "', argument " "18"" of type '" "Real""'");
  } 
  arg18 = static_cast< Real >(val18);
  {
    try {
      result = (CPISwap *)new CPISwap(arg1,arg2,arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(BusinessDayConvention const &)*arg7,arg8,(ext::shared_ptr< IborIndex > const &)*arg9,arg10,arg11,(DayCounter const &)*arg12,(Schedule const &)*arg13,(BusinessDayConvention const &)*arg14,(Period const &)*arg15,(ext::shared_ptr< ZeroInflationIndex > const &)*arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPISwap > *smartresult = result ? new ext::shared_ptr<  CPISwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPISwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  bool arg3 ;
  Spread arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  BusinessDayConvention *arg7 = 0 ;
  Natural arg8 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Rate arg10 ;
  Real arg11 ;
  DayCounter *arg12 = 0 ;
  Schedule *arg13 = 0 ;
  BusinessDayConvention *arg14 = 0 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg16 = 0 ;
  CPI::InterpolationType arg17 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 ;
  BusinessDayConvention temp7 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< IborIndex > tempshared9 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 ;
  BusinessDayConvention temp14 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared16 ;
  int val17 ;
  int ecode17 = 0 ;
  CPISwap *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPISwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CPISwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPISwap" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPISwap" "', argument " "4"" of type '" "Spread""'");
  } 
  arg4 = static_cast< Spread >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPISwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPISwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  ecode7 = SWIG_AsVal_int (swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CPISwap" "', argument " "7"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp7 = static_cast< BusinessDayConvention >(val7);
    arg7 = &temp7;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPISwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPISwap" "', argument " "9"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9) : &tempshared9;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPISwap" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPISwap" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPISwap" "', argument " "12"" of type '" "DayCounter const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "12"" of type '" "DayCounter const &""'"); 
  }
  arg12 = reinterpret_cast< DayCounter * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPISwap" "', argument " "13"" of type '" "Schedule const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "13"" of type '" "Schedule const &""'"); 
  }
  arg13 = reinterpret_cast< Schedule * >(argp13);
  ecode14 = SWIG_AsVal_int (swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CPISwap" "', argument " "14"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp14 = static_cast< BusinessDayConvention >(val14);
    arg14 = &temp14;
  }
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CPISwap" "', argument " "15"" of type '" "Period const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "15"" of type '" "Period const &""'"); 
  }
  arg15 = reinterpret_cast< Period * >(argp15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_CPISwap" "', argument " "16"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16) : &tempshared16;
    }
  }
  ecode17 = SWIG_AsVal_int(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_CPISwap" "', argument " "17"" of type '" "CPI::InterpolationType""'");
  } 
  arg17 = static_cast< CPI::InterpolationType >(val17);
  {
    try {
      result = (CPISwap *)new CPISwap(arg1,arg2,arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(BusinessDayConvention const &)*arg7,arg8,(ext::shared_ptr< IborIndex > const &)*arg9,arg10,arg11,(DayCounter const &)*arg12,(Schedule const &)*arg13,(BusinessDayConvention const &)*arg14,(Period const &)*arg15,(ext::shared_ptr< ZeroInflationIndex > const &)*arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPISwap > *smartresult = result ? new ext::shared_ptr<  CPISwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPISwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swap::Type arg1 ;
  Real arg2 ;
  bool arg3 ;
  Spread arg4 ;
  DayCounter *arg5 = 0 ;
  Schedule *arg6 = 0 ;
  BusinessDayConvention *arg7 = 0 ;
  Natural arg8 ;
  ext::shared_ptr< IborIndex > *arg9 = 0 ;
  Rate arg10 ;
  Real arg11 ;
  DayCounter *arg12 = 0 ;
  Schedule *arg13 = 0 ;
  BusinessDayConvention *arg14 = 0 ;
  Period *arg15 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg16 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 ;
  BusinessDayConvention temp7 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< IborIndex > tempshared9 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 ;
  BusinessDayConvention temp14 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 ;
  int res16 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared16 ;
  CPISwap *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPISwap" "', argument " "1"" of type '" "Swap::Type""'");
  } 
  arg1 = static_cast< Swap::Type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CPISwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPISwap" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPISwap" "', argument " "4"" of type '" "Spread""'");
  } 
  arg4 = static_cast< Spread >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPISwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPISwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "6"" of type '" "Schedule const &""'"); 
  }
  arg6 = reinterpret_cast< Schedule * >(argp6);
  ecode7 = SWIG_AsVal_int (swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CPISwap" "', argument " "7"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp7 = static_cast< BusinessDayConvention >(val7);
    arg7 = &temp7;
  }
  ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CPISwap" "', argument " "8"" of type '" "Natural""'");
  } 
  arg8 = static_cast< Natural >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPISwap" "', argument " "9"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp9) : &tempshared9;
    }
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CPISwap" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPISwap" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPISwap" "', argument " "12"" of type '" "DayCounter const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "12"" of type '" "DayCounter const &""'"); 
  }
  arg12 = reinterpret_cast< DayCounter * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPISwap" "', argument " "13"" of type '" "Schedule const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "13"" of type '" "Schedule const &""'"); 
  }
  arg13 = reinterpret_cast< Schedule * >(argp13);
  ecode14 = SWIG_AsVal_int (swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CPISwap" "', argument " "14"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp14 = static_cast< BusinessDayConvention >(val14);
    arg14 = &temp14;
  }
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CPISwap" "', argument " "15"" of type '" "Period const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPISwap" "', argument " "15"" of type '" "Period const &""'"); 
  }
  arg15 = reinterpret_cast< Period * >(argp15);
  {
    int newmem = 0;
    res16 = SWIG_ConvertPtrAndOwn(swig_obj[15], &argp16, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_CPISwap" "', argument " "16"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp16) tempshared16 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16);
      arg16 = &tempshared16;
    } else {
      arg16 = (argp16) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp16) : &tempshared16;
    }
  }
  {
    try {
      result = (CPISwap *)new CPISwap(arg1,arg2,arg3,arg4,(DayCounter const &)*arg5,(Schedule const &)*arg6,(BusinessDayConvention const &)*arg7,arg8,(ext::shared_ptr< IborIndex > const &)*arg9,arg10,arg11,(DayCounter const &)*arg12,(Schedule const &)*arg13,(BusinessDayConvention const &)*arg14,(Period const &)*arg15,(ext::shared_ptr< ZeroInflationIndex > const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPISwap > *smartresult = result ? new ext::shared_ptr<  CPISwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPISwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[19] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CPISwap", 0, 18, argv))) SWIG_fail;
  --argc;
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_CPISwap__SWIG_2(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_CPISwap__SWIG_1(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_double(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_new_CPISwap__SWIG_0(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CPISwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CPISwap::CPISwap(Swap::Type,Real,bool,Spread,DayCounter const &,Schedule const &,BusinessDayConvention const &,Natural,ext::shared_ptr< IborIndex > const &,Rate,Real,DayCounter const &,Schedule const &,BusinessDayConvention const &,Period const &,ext::shared_ptr< ZeroInflationIndex > const &,CPI::InterpolationType,Real)\n"
    "    CPISwap::CPISwap(Swap::Type,Real,bool,Spread,DayCounter const &,Schedule const &,BusinessDayConvention const &,Natural,ext::shared_ptr< IborIndex > const &,Rate,Real,DayCounter const &,Schedule const &,BusinessDayConvention const &,Period const &,ext::shared_ptr< ZeroInflationIndex > const &,CPI::InterpolationType)\n"
    "    CPISwap::CPISwap(Swap::Type,Real,bool,Spread,DayCounter const &,Schedule const &,BusinessDayConvention const &,Natural,ext::shared_ptr< IborIndex > const &,Rate,Real,DayCounter const &,Schedule const &,BusinessDayConvention const &,Period const &,ext::shared_ptr< ZeroInflationIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CPISwap_fairRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPISwap_fairRate" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->fairRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPISwap_floatLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPISwap_floatLegNPV" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->floatLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPISwap_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPISwap_fairSpread" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPISwap_fixedLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPISwap_fixedLegNPV" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->fixedLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPISwap_cpiLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPISwap_cpiLeg" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->cpiLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CPISwap_floatLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CPISwap_floatLeg" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &(arg1)->floatLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CPISwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPISwap *arg1 = (CPISwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPISwap > tempshared1 ;
  ext::shared_ptr< CPISwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPISwap" "', argument " "1"" of type '" "CPISwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPISwap > * >(argp1);
      arg1 = const_cast< CPISwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPISwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CPISwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPISwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationCapFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor::Type arg1 ;
  Leg *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  YoYInflationCapFloor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationCapFloor", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYInflationCapFloor" "', argument " "1"" of type '" "YoYInflationCapFloor::Type""'");
  } 
  arg1 = static_cast< YoYInflationCapFloor::Type >(val1);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCapFloor" "', argument " "2"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloor" "', argument " "2"" of type '" "Leg const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCapFloor" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloor" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (YoYInflationCapFloor *)new YoYInflationCapFloor(arg1,(Leg const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCapFloor > *smartresult = result ? new ext::shared_ptr<  YoYInflationCapFloor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor const > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Volatility result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "1"" of type '" "YoYInflationCapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor const > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "1"" of type '" "YoYInflationCapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor const > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "1"" of type '" "YoYInflationCapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor const > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "1"" of type '" "YoYInflationCapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  Real arg2 ;
  Handle< YoYInflationTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor const > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "1"" of type '" "YoYInflationCapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YoYInflationTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YoYInflationTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYInflationCapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  {
    try {
      result = (Volatility)((YoYInflationCapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YoYInflationTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYInflationCapFloor_impliedVolatility", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YoYInflationCapFloor_impliedVolatility__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_YoYInflationCapFloor_impliedVolatility__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_YoYInflationCapFloor_impliedVolatility__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_YoYInflationCapFloor_impliedVolatility__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YoYInflationTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_YoYInflationCapFloor_impliedVolatility__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYInflationCapFloor_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYInflationCapFloor::impliedVolatility(Real,Handle< YoYInflationTermStructure > const &,Volatility,Real,Size,Volatility,Volatility) const\n"
    "    YoYInflationCapFloor::impliedVolatility(Real,Handle< YoYInflationTermStructure > const &,Volatility,Real,Size,Volatility) const\n"
    "    YoYInflationCapFloor::impliedVolatility(Real,Handle< YoYInflationTermStructure > const &,Volatility,Real,Size) const\n"
    "    YoYInflationCapFloor::impliedVolatility(Real,Handle< YoYInflationTermStructure > const &,Volatility,Real) const\n"
    "    YoYInflationCapFloor::impliedVolatility(Real,Handle< YoYInflationTermStructure > const &,Volatility) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYInflationCapFloor_optionletPrices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCapFloor_optionletPrices" "', argument " "1"" of type '" "YoYInflationCapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = YoYInflationCapFloor_optionletPrices(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCapFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCapFloor *arg1 = (YoYInflationCapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloor > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCapFloor" "', argument " "1"" of type '" "YoYInflationCapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloor > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCapFloor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationCapFloor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationCap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  YoYInflationCap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationCap", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCap" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCap" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (YoYInflationCap *)new YoYInflationCap((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCap > *smartresult = result ? new ext::shared_ptr<  YoYInflationCap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCap *arg1 = (YoYInflationCap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCap > tempshared1 ;
  ext::shared_ptr< YoYInflationCap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCap" "', argument " "1"" of type '" "YoYInflationCap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCap > * >(argp1);
      arg1 = const_cast< YoYInflationCap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCap > * >(argp1);
      arg1 = const_cast< YoYInflationCap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationCap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationCap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  YoYInflationFloor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationFloor", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationFloor" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationFloor" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationFloor" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationFloor" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (YoYInflationFloor *)new YoYInflationFloor((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationFloor > *smartresult = result ? new ext::shared_ptr<  YoYInflationFloor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationFloor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationFloor *arg1 = (YoYInflationFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationFloor > tempshared1 ;
  ext::shared_ptr< YoYInflationFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationFloor" "', argument " "1"" of type '" "YoYInflationFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationFloor > * >(argp1);
      arg1 = const_cast< YoYInflationFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationFloor > * >(argp1);
      arg1 = const_cast< YoYInflationFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationFloor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationFloor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationFloor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationCollar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  YoYInflationCollar *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationCollar", 3, 3, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCollar" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCollar" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCollar" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCollar" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCollar" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCollar" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (YoYInflationCollar *)new YoYInflationCollar((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCollar > *smartresult = result ? new ext::shared_ptr<  YoYInflationCollar >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCollar_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCollar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCollar *arg1 = (YoYInflationCollar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCollar > tempshared1 ;
  ext::shared_ptr< YoYInflationCollar > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCollar_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCollar" "', argument " "1"" of type '" "YoYInflationCollar *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCollar > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCollar > * >(argp1);
      arg1 = const_cast< YoYInflationCollar * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCollar > * >(argp1);
      arg1 = const_cast< YoYInflationCollar * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCollar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationCollar_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationCollar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZeroInflationCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  Linear *arg8 = 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 val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  InterpolatedZeroInflationCurve< Linear > *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroInflationCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroInflationCurve" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroInflationCurve" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationCurve" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationCurve" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ZeroInflationCurve" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "8"" of type '" "Linear const &""'"); 
  }
  arg8 = reinterpret_cast< Linear * >(argp8);
  {
    try {
      result = (InterpolatedZeroInflationCurve< Linear > *)new InterpolatedZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7,(Linear const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  InterpolatedZeroInflationCurve< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroInflationCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroInflationCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroInflationCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroInflationCurve" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroInflationCurve" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ZeroInflationCurve" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroInflationCurve" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroInflationCurve" "', argument " "7"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      result = (InterpolatedZeroInflationCurve< Linear > *)new InterpolatedZeroInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(std::vector< Rate,std::allocator< Rate > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroInflationCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroInflationCurve", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ZeroInflationCurve__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_ZeroInflationCurve__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroInflationCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroInflationCurve< Linear >::InterpolatedZeroInflationCurve(Date const &,Calendar const &,DayCounter const &,Period const &,Frequency,std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,Linear const &)\n"
    "    InterpolatedZeroInflationCurve< Linear >::InterpolatedZeroInflationCurve(Date const &,Calendar const &,DayCounter const &,Period const &,Frequency,std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroInflationCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCurve_times" "', argument " "1"" of type '" "InterpolatedZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroInflationCurve< Linear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCurve_data" "', argument " "1"" of type '" "InterpolatedZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroInflationCurve< Linear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCurve_rates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCurve_rates" "', argument " "1"" of type '" "InterpolatedZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroInflationCurve< Linear > const *)arg1)->rates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroInflationCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroInflationCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroInflationCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroInflationCurve< Linear > *arg1 = (InterpolatedZeroInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroInflationCurve" "', argument " "1"" of type '" "InterpolatedZeroInflationCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroInflationCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroInflationCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationCurve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Period *arg4 = 0 ;
  Frequency arg5 ;
  bool arg6 ;
  std::vector< Date,std::allocator< Date > > *arg7 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg8 = 0 ;
  Linear const &arg9_defvalue = Linear() ;
  Linear *arg9 = (Linear *) &arg9_defvalue ;
  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 val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  int res8 = SWIG_OLDOBJ ;
  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 ;
  char * kwnames[] = {
    (char *)"referenceDate",  (char *)"calendar",  (char *)"dayCounter",  (char *)"lag",  (char *)"frequency",  (char *)"indexIsInterpolated",  (char *)"dates",  (char *)"rates",  (char *)"interpolator",  NULL 
  };
  InterpolatedYoYInflationCurve< Linear > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO|O:new_YoYInflationCurve", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYInflationCurve" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_YoYInflationCurve" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_YoYInflationCurve" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res7 = swig::asptr(obj6, &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCurve" "', argument " "7"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "7"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(obj7, &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYInflationCurve" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "8"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg8 = ptr;
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Linear,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_YoYInflationCurve" "', argument " "9"" of type '" "Linear const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCurve" "', argument " "9"" of type '" "Linear const &""'"); 
    }
    arg9 = reinterpret_cast< Linear * >(argp9);
  }
  {
    try {
      result = (InterpolatedYoYInflationCurve< Linear > *)new InterpolatedYoYInflationCurve< Linear >((Date const &)*arg1,(Calendar const &)*arg2,(DayCounter const &)*arg3,(Period const &)*arg4,arg5,arg6,(std::vector< Date,std::allocator< Date > > const &)*arg7,(std::vector< Rate,std::allocator< Rate > > const &)*arg8,(Linear const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res7)) delete arg7;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCurve_dates" "', argument " "1"" of type '" "InterpolatedYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedYoYInflationCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCurve_times" "', argument " "1"" of type '" "InterpolatedYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedYoYInflationCurve< Linear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCurve_data" "', argument " "1"" of type '" "InterpolatedYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedYoYInflationCurve< Linear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCurve_rates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCurve_rates" "', argument " "1"" of type '" "InterpolatedYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedYoYInflationCurve< Linear > const *)arg1)->rates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYInflationCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYInflationCurve_nodes" "', argument " "1"" of type '" "InterpolatedYoYInflationCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedYoYInflationCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYInflationCurve< Linear > *arg1 = (InterpolatedYoYInflationCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCurve" "', argument " "1"" of type '" "InterpolatedYoYInflationCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedYoYInflationCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYInflationCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< std::vector< Time,std::allocator< Time > >,std::vector< Rate,std::allocator< Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapTimeRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapDateRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::pair< std::vector< Date,std::allocator< Date > >,std::vector< double,std::allocator< double > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapDateRates" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapDateRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::pair< std::vector< Date,std::allocator< Date > >,std::vector< Rate,std::allocator< Rate > > >(result)), SWIGTYPE_p_std__pairT_std__vectorT_Date_std__allocatorT_Date_t_t_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_YoYTS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYInflationTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_YoYTS" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->YoYTS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationTermStructure > *smartresult = result ? new ext::shared_ptr<  YoYInflationTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_yoyIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< YoYInflationIndex > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_yoyIndex" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->yoyIndex();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationIndex > *smartresult = result ? new ext::shared_ptr<  YoYInflationIndex >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_businessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_businessDayConvention" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)((YoYCapFloorTermPriceSurface const *)arg1)->businessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_fixingDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Natural result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_fixingDays" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Natural)((YoYCapFloorTermPriceSurface const *)arg1)->fixingDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_price__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(arg1)->price((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_capPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(arg1)->capPrice((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_floorPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)(arg1)->floorPrice((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)(arg1)->atmYoYSwapRate((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)(arg1)->atmYoYSwapRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Rate)(arg1)->atmYoYRate((Date const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)(arg1)->atmYoYRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)(arg1)->atmYoYRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_price__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_price" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((YoYCapFloorTermPriceSurface const *)arg1)->price((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_price(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYCapFloorTermPriceSurface_price", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_price__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_price__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYCapFloorTermPriceSurface_price'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYCapFloorTermPriceSurface::price(Date const &,Rate)\n"
    "    YoYCapFloorTermPriceSurface::price(Period const &,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_capPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_capPrice" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((YoYCapFloorTermPriceSurface const *)arg1)->capPrice((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_capPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYCapFloorTermPriceSurface_capPrice", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_capPrice__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_capPrice__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYCapFloorTermPriceSurface_capPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYCapFloorTermPriceSurface::capPrice(Date const &,Rate)\n"
    "    YoYCapFloorTermPriceSurface::capPrice(Period const &,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_floorPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_floorPrice" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Real)((YoYCapFloorTermPriceSurface const *)arg1)->floorPrice((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_floorPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYCapFloorTermPriceSurface_floorPrice", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_floorPrice__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_floorPrice__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYCapFloorTermPriceSurface_floorPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYCapFloorTermPriceSurface::floorPrice(Date const &,Rate)\n"
    "    YoYCapFloorTermPriceSurface::floorPrice(Period const &,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapRate((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYSwapRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYSwapRate((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYCapFloorTermPriceSurface_atmYoYSwapRate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYCapFloorTermPriceSurface_atmYoYSwapRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYCapFloorTermPriceSurface::atmYoYSwapRate(Date const &,bool)\n"
    "    YoYCapFloorTermPriceSurface::atmYoYSwapRate(Date const &)\n"
    "    YoYCapFloorTermPriceSurface::atmYoYSwapRate(Period const &,bool) const\n"
    "    YoYCapFloorTermPriceSurface::atmYoYSwapRate(Period const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYRate((Period const &)*arg2,(Period const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYRate((Period const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_atmYoYRate" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->atmYoYRate((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_atmYoYRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "YoYCapFloorTermPriceSurface_atmYoYRate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_YoYCapFloorTermPriceSurface_atmYoYRate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'YoYCapFloorTermPriceSurface_atmYoYRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYCapFloorTermPriceSurface::atmYoYRate(Date const &,Period const &,bool)\n"
    "    YoYCapFloorTermPriceSurface::atmYoYRate(Date const &,Period const &)\n"
    "    YoYCapFloorTermPriceSurface::atmYoYRate(Date const &)\n"
    "    YoYCapFloorTermPriceSurface::atmYoYRate(Period const &,Period const &,bool) const\n"
    "    YoYCapFloorTermPriceSurface::atmYoYRate(Period const &,Period const &) const\n"
    "    YoYCapFloorTermPriceSurface::atmYoYRate(Period const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_strikes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_strikes" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->strikes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_capStrikes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_capStrikes" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->capStrikes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_floorStrikes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_floorStrikes" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->floorStrikes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_maturities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period,std::allocator< Period > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_maturities" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->maturities();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Period,std::allocator< Period > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_minStrike" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_maxStrike" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((YoYCapFloorTermPriceSurface const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_minMaturity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_minMaturity" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->minMaturity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_maxMaturity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_maxMaturity" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->maxMaturity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  Period *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Date result;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    try {
      result = ((YoYCapFloorTermPriceSurface const *)arg1)->yoyOptionDateFromTenor((Period const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYCapFloorTermPriceSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYCapFloorTermPriceSurface *arg1 = (YoYCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYCapFloorTermPriceSurface" "', argument " "1"" of type '" "YoYCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYCapFloorTermPriceSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Rate arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention *arg8 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg11 = 0 ;
  Matrix *arg12 = 0 ;
  Matrix *arg13 = 0 ;
  Bicubic *arg14 = 0 ;
  Cubic *arg15 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 ;
  BusinessDayConvention temp8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  Matrix temp12 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  Matrix temp13 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  YoYInflationCapFloorTermPriceSurface *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "3"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int (swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "8"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp8 = static_cast< BusinessDayConvention >(val8);
    arg8 = &temp8;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg10 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res11 = swig::asptr(swig_obj[10], &ptr);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "11"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "11"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg11 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[11]) || PyList_Check(swig_obj[11])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[11]) ?
      PyTuple_Size(swig_obj[11]) :
        PyList_Size(swig_obj[11]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[11],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp12 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[11],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp12[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp12[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg12 = &temp12;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res12)) {
        SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "12"" of type '" "Matrix const &""'");
      }
      if (!argp12) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "12"" of type '" "Matrix const &""'"); 
      }
      arg12 = reinterpret_cast< Matrix * >(argp12);
    }
  }
  {
    if (PyTuple_Check(swig_obj[12]) || PyList_Check(swig_obj[12])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[12]) ?
      PyTuple_Size(swig_obj[12]) :
        PyList_Size(swig_obj[12]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[12],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp13 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[12],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp13[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp13[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg13 = &temp13;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res13)) {
        SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "13"" of type '" "Matrix const &""'");
      }
      if (!argp13) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "13"" of type '" "Matrix const &""'"); 
      }
      arg13 = reinterpret_cast< Matrix * >(argp13);
    }
  }
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Bicubic,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "14"" of type '" "Bicubic const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "14"" of type '" "Bicubic const &""'"); 
  }
  arg14 = reinterpret_cast< Bicubic * >(argp14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "15"" of type '" "Cubic const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "15"" of type '" "Cubic const &""'"); 
  }
  arg15 = reinterpret_cast< Cubic * >(argp15);
  {
    try {
      result = (YoYInflationCapFloorTermPriceSurface *)new_YoYInflationCapFloorTermPriceSurface__SWIG_0(arg1,(Period const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,(enum BusinessDayConvention const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(std::vector< Period,std::allocator< Period > > const &)*arg11,(Matrix const &)*arg12,(Matrix const &)*arg13,(Bicubic const &)*arg14,(Cubic const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > *smartresult = result ? new ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Rate arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention *arg8 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg11 = 0 ;
  Matrix *arg12 = 0 ;
  Matrix *arg13 = 0 ;
  Bicubic *arg14 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 ;
  BusinessDayConvention temp8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  Matrix temp12 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  Matrix temp13 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  YoYInflationCapFloorTermPriceSurface *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "3"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int (swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "8"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp8 = static_cast< BusinessDayConvention >(val8);
    arg8 = &temp8;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg10 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res11 = swig::asptr(swig_obj[10], &ptr);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "11"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "11"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg11 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[11]) || PyList_Check(swig_obj[11])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[11]) ?
      PyTuple_Size(swig_obj[11]) :
        PyList_Size(swig_obj[11]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[11],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp12 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[11],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp12[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp12[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg12 = &temp12;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res12)) {
        SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "12"" of type '" "Matrix const &""'");
      }
      if (!argp12) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "12"" of type '" "Matrix const &""'"); 
      }
      arg12 = reinterpret_cast< Matrix * >(argp12);
    }
  }
  {
    if (PyTuple_Check(swig_obj[12]) || PyList_Check(swig_obj[12])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[12]) ?
      PyTuple_Size(swig_obj[12]) :
        PyList_Size(swig_obj[12]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[12],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp13 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[12],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp13[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp13[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg13 = &temp13;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res13)) {
        SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "13"" of type '" "Matrix const &""'");
      }
      if (!argp13) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "13"" of type '" "Matrix const &""'"); 
      }
      arg13 = reinterpret_cast< Matrix * >(argp13);
    }
  }
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_Bicubic,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "14"" of type '" "Bicubic const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "14"" of type '" "Bicubic const &""'"); 
  }
  arg14 = reinterpret_cast< Bicubic * >(argp14);
  {
    try {
      result = (YoYInflationCapFloorTermPriceSurface *)new_YoYInflationCapFloorTermPriceSurface__SWIG_0(arg1,(Period const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,(enum BusinessDayConvention const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(std::vector< Period,std::allocator< Period > > const &)*arg11,(Matrix const &)*arg12,(Matrix const &)*arg13,(Bicubic const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > *smartresult = result ? new ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  ext::shared_ptr< YoYInflationIndex > *arg3 = 0 ;
  Rate arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention *arg8 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg11 = 0 ;
  Matrix *arg12 = 0 ;
  Matrix *arg13 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 ;
  BusinessDayConvention temp8 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  Matrix temp12 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  Matrix temp13 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  YoYInflationCapFloorTermPriceSurface *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "3"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int (swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "8"" of type '" "BusinessDayConvention const &""'");
  } else {
    temp8 = static_cast< BusinessDayConvention >(val8);
    arg8 = &temp8;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg10 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res11 = swig::asptr(swig_obj[10], &ptr);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "11"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "11"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg11 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[11]) || PyList_Check(swig_obj[11])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[11]) ?
      PyTuple_Size(swig_obj[11]) :
        PyList_Size(swig_obj[11]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[11],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp12 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[11],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp12[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp12[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg12 = &temp12;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res12)) {
        SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "12"" of type '" "Matrix const &""'");
      }
      if (!argp12) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "12"" of type '" "Matrix const &""'"); 
      }
      arg12 = reinterpret_cast< Matrix * >(argp12);
    }
  }
  {
    if (PyTuple_Check(swig_obj[12]) || PyList_Check(swig_obj[12])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[12]) ?
      PyTuple_Size(swig_obj[12]) :
        PyList_Size(swig_obj[12]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[12],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp13 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[12],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp13[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp13[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg13 = &temp13;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res13)) {
        SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "13"" of type '" "Matrix const &""'");
      }
      if (!argp13) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationCapFloorTermPriceSurface" "', argument " "13"" of type '" "Matrix const &""'"); 
      }
      arg13 = reinterpret_cast< Matrix * >(argp13);
    }
  }
  {
    try {
      result = (YoYInflationCapFloorTermPriceSurface *)new_YoYInflationCapFloorTermPriceSurface__SWIG_0(arg1,(Period const &)*arg2,(ext::shared_ptr< YoYInflationIndex > const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,(enum BusinessDayConvention const &)*arg8,(std::vector< double,std::allocator< double > > const &)*arg9,(std::vector< double,std::allocator< double > > const &)*arg10,(std::vector< Period,std::allocator< Period > > const &)*arg11,(Matrix const &)*arg12,(Matrix const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > *smartresult = result ? new ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YoYInflationCapFloorTermPriceSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_YoYInflationCapFloorTermPriceSurface", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = swig::asptr(argv[10], (std::vector< Period,std::allocator< Period > >**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            /* native sequence? */
                            if (PyTuple_Check(argv[11]) || PyList_Check(argv[11])) {
                              _v = 1;
                              /* wrapped Matrix? */
                            } else {
                              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                              _v = SWIG_CheckState(res);
                            }
                          }
                          if (_v) {
                            {
                              /* native sequence? */
                              if (PyTuple_Check(argv[12]) || PyList_Check(argv[12])) {
                                _v = 1;
                                /* wrapped Matrix? */
                              } else {
                                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                                _v = SWIG_CheckState(res);
                              }
                            }
                            if (_v) {
                              return _wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = swig::asptr(argv[10], (std::vector< Period,std::allocator< Period > >**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            /* native sequence? */
                            if (PyTuple_Check(argv[11]) || PyList_Check(argv[11])) {
                              _v = 1;
                              /* wrapped Matrix? */
                            } else {
                              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                              _v = SWIG_CheckState(res);
                            }
                          }
                          if (_v) {
                            {
                              /* native sequence? */
                              if (PyTuple_Check(argv[12]) || PyList_Check(argv[12])) {
                                _v = 1;
                                /* wrapped Matrix? */
                              } else {
                                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                                _v = SWIG_CheckState(res);
                              }
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Bicubic, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = swig::asptr(argv[9], (std::vector< double,std::allocator< double > >**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = swig::asptr(argv[10], (std::vector< Period,std::allocator< Period > >**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            /* native sequence? */
                            if (PyTuple_Check(argv[11]) || PyList_Check(argv[11])) {
                              _v = 1;
                              /* wrapped Matrix? */
                            } else {
                              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                              _v = SWIG_CheckState(res);
                            }
                          }
                          if (_v) {
                            {
                              /* native sequence? */
                              if (PyTuple_Check(argv[12]) || PyList_Check(argv[12])) {
                                _v = 1;
                                /* wrapped Matrix? */
                              } else {
                                // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                                _v = SWIG_CheckState(res);
                              }
                            }
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_Bicubic, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_YoYInflationCapFloorTermPriceSurface__SWIG_0(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_YoYInflationCapFloorTermPriceSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    YoYInflationCapFloorTermPriceSurface::YoYInflationCapFloorTermPriceSurface(Natural,Period const &,ext::shared_ptr< YoYInflationIndex > const &,Rate,Handle< YieldTermStructure > const &,DayCounter const &,Calendar const &,BusinessDayConvention const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,Matrix const &,Bicubic const &,Cubic const &)\n"
    "    YoYInflationCapFloorTermPriceSurface::YoYInflationCapFloorTermPriceSurface(Natural,Period const &,ext::shared_ptr< YoYInflationIndex > const &,Rate,Handle< YieldTermStructure > const &,DayCounter const &,Calendar const &,BusinessDayConvention const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,Matrix const &,Bicubic const &)\n"
    "    YoYInflationCapFloorTermPriceSurface::YoYInflationCapFloorTermPriceSurface(Natural,Period const &,ext::shared_ptr< YoYInflationIndex > const &,Rate,Handle< YieldTermStructure > const &,DayCounter const &,Calendar const &,BusinessDayConvention const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< Period,std::allocator< Period > > const &,Matrix const &,Matrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationCapFloorTermPriceSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationCapFloorTermPriceSurface *arg1 = (YoYInflationCapFloorTermPriceSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > tempshared1 ;
  ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationCapFloorTermPriceSurface" "', argument " "1"" of type '" "YoYInflationCapFloorTermPriceSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloorTermPriceSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationCapFloorTermPriceSurface > * >(argp1);
      arg1 = const_cast< YoYInflationCapFloorTermPriceSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationCapFloorTermPriceSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationCapFloorTermPriceSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationBlackCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYInflationIndex > *arg1 = 0 ;
  Handle< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  YoYInflationBlackCapFloorEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationBlackCapFloorEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationBlackCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationBlackCapFloorEngine" "', argument " "2"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationBlackCapFloorEngine" "', argument " "2"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationBlackCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationBlackCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (YoYInflationBlackCapFloorEngine *)new YoYInflationBlackCapFloorEngine((ext::shared_ptr< YoYInflationIndex > const &)*arg1,(Handle< YoYOptionletVolatilitySurface > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationBlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  YoYInflationBlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationBlackCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationBlackCapFloorEngine *arg1 = (YoYInflationBlackCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationBlackCapFloorEngine > tempshared1 ;
  ext::shared_ptr< YoYInflationBlackCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationBlackCapFloorEngine" "', argument " "1"" of type '" "YoYInflationBlackCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationBlackCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationBlackCapFloorEngine > * >(argp1);
      arg1 = const_cast< YoYInflationBlackCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationBlackCapFloorEngine > * >(argp1);
      arg1 = const_cast< YoYInflationBlackCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationBlackCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationBlackCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationUnitDisplacedBlackCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYInflationIndex > *arg1 = 0 ;
  Handle< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  YoYInflationUnitDisplacedBlackCapFloorEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationUnitDisplacedBlackCapFloorEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationUnitDisplacedBlackCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationUnitDisplacedBlackCapFloorEngine" "', argument " "2"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationUnitDisplacedBlackCapFloorEngine" "', argument " "2"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationUnitDisplacedBlackCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationUnitDisplacedBlackCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (YoYInflationUnitDisplacedBlackCapFloorEngine *)new YoYInflationUnitDisplacedBlackCapFloorEngine((ext::shared_ptr< YoYInflationIndex > const &)*arg1,(Handle< YoYOptionletVolatilitySurface > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationUnitDisplacedBlackCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationUnitDisplacedBlackCapFloorEngine *arg1 = (YoYInflationUnitDisplacedBlackCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > tempshared1 ;
  ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationUnitDisplacedBlackCapFloorEngine" "', argument " "1"" of type '" "YoYInflationUnitDisplacedBlackCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine > * >(argp1);
      arg1 = const_cast< YoYInflationUnitDisplacedBlackCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationUnitDisplacedBlackCapFloorEngine > * >(argp1);
      arg1 = const_cast< YoYInflationUnitDisplacedBlackCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYInflationBachelierCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< YoYInflationIndex > *arg1 = 0 ;
  Handle< YoYOptionletVolatilitySurface > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  YoYInflationBachelierCapFloorEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYInflationBachelierCapFloorEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYInflationBachelierCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YoYOptionletVolatilitySurface_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_YoYInflationBachelierCapFloorEngine" "', argument " "2"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationBachelierCapFloorEngine" "', argument " "2"" of type '" "Handle< YoYOptionletVolatilitySurface > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YoYOptionletVolatilitySurface > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_YoYInflationBachelierCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYInflationBachelierCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (YoYInflationBachelierCapFloorEngine *)new YoYInflationBachelierCapFloorEngine((ext::shared_ptr< YoYInflationIndex > const &)*arg1,(Handle< YoYOptionletVolatilitySurface > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYInflationBachelierCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  YoYInflationBachelierCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYInflationBachelierCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYInflationBachelierCapFloorEngine *arg1 = (YoYInflationBachelierCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYInflationBachelierCapFloorEngine > tempshared1 ;
  ext::shared_ptr< YoYInflationBachelierCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYInflationBachelierCapFloorEngine" "', argument " "1"" of type '" "YoYInflationBachelierCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYInflationBachelierCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYInflationBachelierCapFloorEngine > * >(argp1);
      arg1 = const_cast< YoYInflationBachelierCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYInflationBachelierCapFloorEngine > * >(argp1);
      arg1 = const_cast< YoYInflationBachelierCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYInflationBachelierCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYInflationBachelierCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_YoYOptionletHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Real arg2 ;
  YoYInflationCapFloor::Type arg3 ;
  Period *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  Calendar *arg6 = 0 ;
  Natural arg7 ;
  ext::shared_ptr< YoYInflationIndex > *arg8 = 0 ;
  Rate arg9 ;
  Size arg10 ;
  ext::shared_ptr< PricingEngine > *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< YoYInflationIndex > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared11 ;
  PyObject *swig_obj[11] ;
  YoYOptionletHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_YoYOptionletHelper", 11, 11, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YoYOptionletHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYOptionletHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_YoYOptionletHelper" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_YoYOptionletHelper" "', argument " "3"" of type '" "YoYInflationCapFloor::Type""'");
  } 
  arg3 = static_cast< YoYInflationCapFloor::Type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_YoYOptionletHelper" "', argument " "4"" of type '" "Period &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYOptionletHelper" "', argument " "4"" of type '" "Period &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_YoYOptionletHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYOptionletHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_YoYOptionletHelper" "', argument " "6"" of type '" "Calendar const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YoYOptionletHelper" "', argument " "6"" of type '" "Calendar const &""'"); 
  }
  arg6 = reinterpret_cast< Calendar * >(argp6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_YoYOptionletHelper" "', argument " "7"" of type '" "Natural""'");
  } 
  arg7 = static_cast< Natural >(val7);
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_YoYInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_YoYOptionletHelper" "', argument " "8"" of type '" "ext::shared_ptr< YoYInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< YoYInflationIndex > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_YoYOptionletHelper" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_YoYOptionletHelper" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  {
    int newmem = 0;
    res11 = SWIG_ConvertPtrAndOwn(swig_obj[10], &argp11, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_YoYOptionletHelper" "', argument " "11"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp11) tempshared11 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp11);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp11);
      arg11 = &tempshared11;
    } else {
      arg11 = (argp11) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp11) : &tempshared11;
    }
  }
  {
    try {
      result = (YoYOptionletHelper *)new_YoYOptionletHelper((Handle< Quote > const &)*arg1,arg2,arg3,*arg4,(DayCounter const &)*arg5,(Calendar const &)*arg6,arg7,(ext::shared_ptr< YoYInflationIndex > const &)*arg8,arg9,SWIG_STD_MOVE(arg10),(ext::shared_ptr< PricingEngine > const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  YoYOptionletHelper > *smartresult = result ? new ext::shared_ptr<  YoYOptionletHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_YoYOptionletHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYOptionletHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletHelper *arg1 = (YoYOptionletHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletHelper > tempshared1 ;
  ext::shared_ptr< YoYOptionletHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYOptionletHelper" "', argument " "1"" of type '" "YoYOptionletHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYOptionletHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYOptionletHelper > * >(argp1);
      arg1 = const_cast< YoYOptionletHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYOptionletHelper > * >(argp1);
      arg1 = const_cast< YoYOptionletHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYOptionletHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYOptionletHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *YoYOptionletHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_YoYOptionletStripper_initialize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *arg2 = 0 ;
  ext::shared_ptr< PricingEngine > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletStripper const > tempshared1 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionletStripper_initialize", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletStripper_initialize" "', argument " "1"" of type '" "YoYOptionletStripper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletStripper_initialize" "', argument " "2"" of type '" "ext::shared_ptr< YoYCapFloorTermPriceSurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "YoYOptionletStripper_initialize" "', argument " "3"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "YoYOptionletStripper_initialize" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      YoYOptionletStripper_initialize((YoYOptionletStripper const *)arg1,(ext::shared_ptr< YoYCapFloorTermPriceSurface > const &)*arg2,(ext::shared_ptr< PricingEngine > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletStripper_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletStripper const > tempshared1 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletStripper_maxStrike" "', argument " "1"" of type '" "YoYOptionletStripper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((YoYOptionletStripper const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletStripper_strikes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletStripper const > tempshared1 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletStripper_strikes" "', argument " "1"" of type '" "YoYOptionletStripper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((YoYOptionletStripper const *)arg1)->strikes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_YoYOptionletStripper_slice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletStripper const > tempshared1 ;
  ext::shared_ptr< YoYOptionletStripper const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::pair< std::vector< Rate,std::allocator< Rate > >,std::vector< Volatility,std::allocator< Volatility > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "YoYOptionletStripper_slice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "YoYOptionletStripper_slice" "', argument " "1"" of type '" "YoYOptionletStripper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "YoYOptionletStripper_slice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "YoYOptionletStripper_slice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((YoYOptionletStripper const *)arg1)->slice((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_YoYOptionletStripper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  YoYOptionletStripper *arg1 = (YoYOptionletStripper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > tempshared1 ;
  ext::shared_ptr< YoYOptionletStripper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YoYOptionletStripper" "', argument " "1"" of type '" "YoYOptionletStripper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  YoYOptionletStripper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  YoYOptionletStripper > * >(argp1);
      arg1 = const_cast< YoYOptionletStripper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YoYOptionletStripper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InterpolatedYoYInflationOptionletStripper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYOptionletStripper< Linear > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_InterpolatedYoYInflationOptionletStripper", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (InterpolatedYoYOptionletStripper< Linear > *)new InterpolatedYoYOptionletStripper< Linear >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InterpolatedYoYInflationOptionletStripper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYOptionletStripper< Linear > *arg1 = (InterpolatedYoYOptionletStripper< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYOptionletStripper< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYOptionletStripper< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterpolatedYoYInflationOptionletStripper" "', argument " "1"" of type '" "InterpolatedYoYOptionletStripper< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYOptionletStripper< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedYoYOptionletStripper<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYOptionletStripper< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InterpolatedYoYInflationOptionletStripper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InterpolatedYoYInflationOptionletStripper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  Frequency arg6 ;
  bool arg7 ;
  std::vector< Date,std::allocator< Date > > *arg8 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg9 = 0 ;
  Rate arg10 ;
  Rate arg11 ;
  Linear *arg12 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  InterpolatedYoYOptionletVolatilityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg8 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "9"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "9"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg9 = ptr;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "12"" of type '" "Linear const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "12"" of type '" "Linear const &""'"); 
  }
  arg12 = reinterpret_cast< Linear * >(argp12);
  {
    try {
      result = (InterpolatedYoYOptionletVolatilityCurve< Linear > *)new InterpolatedYoYOptionletVolatilityCurve< Linear >(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,arg6,arg7,(std::vector< Date,std::allocator< Date > > const &)*arg8,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg9,arg10,arg11,(Linear const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  Frequency arg6 ;
  bool arg7 ;
  std::vector< Date,std::allocator< Date > > *arg8 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg9 = 0 ;
  Rate arg10 ;
  Rate arg11 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  InterpolatedYoYOptionletVolatilityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg8 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "9"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "9"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg9 = ptr;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "11"" of type '" "Rate""'");
  } 
  arg11 = static_cast< Rate >(val11);
  {
    try {
      result = (InterpolatedYoYOptionletVolatilityCurve< Linear > *)new InterpolatedYoYOptionletVolatilityCurve< Linear >(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,arg6,arg7,(std::vector< Date,std::allocator< Date > > const &)*arg8,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InterpolatedYoYInflationOptionletVolatilityCurve", 0, 12, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< Date,std::allocator< Date > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve__SWIG_1(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< Date,std::allocator< Date > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve__SWIG_0(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InterpolatedYoYInflationOptionletVolatilityCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedYoYOptionletVolatilityCurve< Linear >::InterpolatedYoYOptionletVolatilityCurve(Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,Frequency,bool,std::vector< Date,std::allocator< Date > > const &,std::vector< Volatility,std::allocator< Volatility > > const &,Rate,Rate,Linear const &)\n"
    "    InterpolatedYoYOptionletVolatilityCurve< Linear >::InterpolatedYoYOptionletVolatilityCurve(Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,Frequency,bool,std::vector< Date,std::allocator< Date > > const &,std::vector< Volatility,std::allocator< Volatility > > const &,Rate,Rate)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InterpolatedYoYInflationOptionletVolatilityCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedYoYOptionletVolatilityCurve< Linear > *arg1 = (InterpolatedYoYOptionletVolatilityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterpolatedYoYInflationOptionletVolatilityCurve" "', argument " "1"" of type '" "InterpolatedYoYOptionletVolatilityCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYOptionletVolatilityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedYoYOptionletVolatilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedYoYOptionletVolatilityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InterpolatedYoYInflationOptionletVolatilityCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InterpolatedYoYInflationOptionletVolatilityCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *arg6 = 0 ;
  ext::shared_ptr< PricingEngine > *arg7 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > *arg8 = 0 ;
  Real arg9 ;
  Linear *arg10 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared7 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "6"" of type '" "ext::shared_ptr< YoYCapFloorTermPriceSurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "7"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp7) : &tempshared7;
    }
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "8"" of type '" "ext::shared_ptr< YoYOptionletStripper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< YoYOptionletStripper > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< YoYOptionletStripper > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< YoYOptionletStripper > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "10"" of type '" "Linear const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "10"" of type '" "Linear const &""'"); 
  }
  arg10 = reinterpret_cast< Linear * >(argp10);
  {
    try {
      result = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *)new_KInterpolatedYoYOptionletVolatilitySurface_Sl_Linear_Sg___SWIG_0(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,(ext::shared_ptr< YoYCapFloorTermPriceSurface > const &)*arg6,(ext::shared_ptr< PricingEngine > const &)*arg7,(ext::shared_ptr< YoYOptionletStripper > const &)*arg8,arg9,(Linear const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> > *smartresult = result ? new ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  DayCounter *arg4 = 0 ;
  Period *arg5 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > *arg6 = 0 ;
  ext::shared_ptr< PricingEngine > *arg7 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > *arg8 = 0 ;
  Real arg9 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< YoYCapFloorTermPriceSurface > tempshared6 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared7 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< YoYOptionletStripper > tempshared8 ;
  double val9 ;
  int ecode9 = 0 ;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "6"" of type '" "ext::shared_ptr< YoYCapFloorTermPriceSurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< YoYCapFloorTermPriceSurface > * >(argp6) : &tempshared6;
    }
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "7"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp7) : &tempshared7;
    }
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "8"" of type '" "ext::shared_ptr< YoYOptionletStripper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< YoYOptionletStripper > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< YoYOptionletStripper > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< YoYOptionletStripper > * >(argp8) : &tempshared8;
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *)new_KInterpolatedYoYOptionletVolatilitySurface_Sl_Linear_Sg___SWIG_0(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4,(Period const &)*arg5,(ext::shared_ptr< YoYCapFloorTermPriceSurface > const &)*arg6,(ext::shared_ptr< PricingEngine > const &)*arg7,(ext::shared_ptr< YoYOptionletStripper > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> > *smartresult = result ? new ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KInterpolatedYoYInflationOptionletVolatilitySurface", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_YoYOptionletStripper_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KInterpolatedYoYInflationOptionletVolatilitySurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KInterpolatedYoYOptionletVolatilitySurface< Linear >::KInterpolatedYoYOptionletVolatilitySurface(Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,ext::shared_ptr< YoYCapFloorTermPriceSurface > const &,ext::shared_ptr< PricingEngine > const &,ext::shared_ptr< YoYOptionletStripper > const &,Real,Linear const &)\n"
    "    KInterpolatedYoYOptionletVolatilitySurface< Linear >::KInterpolatedYoYOptionletVolatilitySurface(Natural,Calendar const &,BusinessDayConvention,DayCounter const &,Period const &,ext::shared_ptr< YoYCapFloorTermPriceSurface > const &,ext::shared_ptr< PricingEngine > const &,ext::shared_ptr< YoYOptionletStripper > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *arg1 = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > const > tempshared1 ;
  ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::pair< std::vector< Rate,std::allocator< Rate > >,std::vector< Volatility,std::allocator< Volatility > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice" "', argument " "1"" of type '" "KInterpolatedYoYOptionletVolatilitySurface< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const KInterpolatedYoYOptionletVolatilitySurface<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const KInterpolatedYoYOptionletVolatilitySurface<Linear> > * >(argp1);
      arg1 = const_cast< KInterpolatedYoYOptionletVolatilitySurface< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const KInterpolatedYoYOptionletVolatilitySurface<Linear> > * >(argp1);
      arg1 = const_cast< KInterpolatedYoYOptionletVolatilitySurface< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = ((KInterpolatedYoYOptionletVolatilitySurface< Linear > const *)arg1)->Dslice((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KInterpolatedYoYInflationOptionletVolatilitySurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KInterpolatedYoYOptionletVolatilitySurface< Linear > *arg1 = (KInterpolatedYoYOptionletVolatilitySurface< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > tempshared1 ;
  ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KInterpolatedYoYInflationOptionletVolatilitySurface" "', argument " "1"" of type '" "KInterpolatedYoYOptionletVolatilitySurface< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> > * >(argp1);
      arg1 = const_cast< KInterpolatedYoYOptionletVolatilitySurface< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  KInterpolatedYoYOptionletVolatilitySurface<Linear> > * >(argp1);
      arg1 = const_cast< KInterpolatedYoYOptionletVolatilitySurface< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_ShortRateModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ShortRateModel *arg1 = (ShortRateModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  ext::shared_ptr< ShortRateModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShortRateModel" "', argument " "1"" of type '" "ShortRateModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ShortRateModel > * >(argp1);
      arg1 = const_cast< ShortRateModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ShortRateModel > * >(argp1);
      arg1 = const_cast< ShortRateModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ShortRateModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ShortRateModelHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  Handle< ShortRateModel > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShortRateModelHandle" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< ShortRateModel > *)new Handle< ShortRateModel >((ext::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_ShortRateModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortRateModelHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< ShortRateModel > *)new Handle< ShortRateModel >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_ShortRateModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortRateModelHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ShortRateModelHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ShortRateModelHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ShortRateModelHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ShortRateModelHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< ShortRateModel >::Handle(ext::shared_ptr< ShortRateModel > const &)\n"
    "    Handle< ShortRateModel >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ShortRateModel > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle___deref__" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ShortRateModel > *smartresult = result ? new ext::shared_ptr<  ShortRateModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ShortRateModel > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_currentLink" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ShortRateModel > *smartresult = result ? new ext::shared_ptr<  ShortRateModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle___nonzero__" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_ShortRateModel_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle___bool__" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_ShortRateModel_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_asObservable" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = Handle_Sl_ShortRateModel_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ShortRateModelHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShortRateModelHandle" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_params" "', argument " "1"" of type '" "Handle< ShortRateModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (*arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_calibrate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_calibrate" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ShortRateModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ShortRateModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ShortRateModelHandle_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(std::vector< bool,std::allocator< bool > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_calibrate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_calibrate" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ShortRateModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ShortRateModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_calibrate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_calibrate" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ShortRateModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_calibrate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_calibrate" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (*arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_calibrate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ShortRateModelHandle_calibrate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ShortRateModelHandle_calibrate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ShortRateModelHandle_calibrate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ShortRateModelHandle_calibrate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector<bool,std::allocator< bool > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_ShortRateModelHandle_calibrate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ShortRateModelHandle_calibrate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &,std::vector< bool,std::allocator< bool > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    CalibratedModel::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_setParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ShortRateModelHandle_setParams", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_setParams" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortRateModelHandle_setParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_setParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (*arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "ShortRateModelHandle_value", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_value" "', argument " "1"" of type '" "Handle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortRateModelHandle_value" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_value" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShortRateModelHandle_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortRateModelHandle_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Real)(*arg1)->value((Array const &)*arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_constraint" "', argument " "1"" of type '" "Handle< ShortRateModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &(*arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Constraint > *smartresult = *result ? new ext::shared_ptr<  Constraint >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_endCriteria" "', argument " "1"" of type '" "Handle< ShortRateModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (EndCriteria::Type)(*arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_problemValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_problemValues" "', argument " "1"" of type '" "Handle< ShortRateModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (Array *) &(*arg1)->problemValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ShortRateModelHandle_functionEvaluation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = (Handle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortRateModelHandle_functionEvaluation" "', argument " "1"" of type '" "Handle< ShortRateModel > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  {
    try {
      result = (Integer)(*arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ShortRateModelHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_ShortRateModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ShortRateModelHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableShortRateModelHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  RelinkableHandle< ShortRateModel > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableShortRateModelHandle" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< ShortRateModel > *)new RelinkableHandle< ShortRateModel >((ext::shared_ptr< ShortRateModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableShortRateModelHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< ShortRateModel > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< ShortRateModel > *)new RelinkableHandle< ShortRateModel >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableShortRateModelHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableShortRateModelHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableShortRateModelHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableShortRateModelHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableShortRateModelHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< ShortRateModel >::RelinkableHandle(ext::shared_ptr< ShortRateModel > const &)\n"
    "    RelinkableHandle< ShortRateModel >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableShortRateModelHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< ShortRateModel > *arg1 = (RelinkableHandle< ShortRateModel > *) 0 ;
  ext::shared_ptr< ShortRateModel > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableShortRateModelHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableShortRateModelHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< ShortRateModel > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableShortRateModelHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< ShortRateModel > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableShortRateModelHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< ShortRateModel > *arg1 = (RelinkableHandle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableShortRateModelHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< ShortRateModel > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_ShortRateModel_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableShortRateModelHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< ShortRateModel > *arg1 = (RelinkableHandle< ShortRateModel > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableShortRateModelHandle" "', argument " "1"" of type '" "RelinkableHandle< ShortRateModel > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< ShortRateModel > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableShortRateModelHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_ShortRateModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableShortRateModelHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_OneFactorAffineModel_discountBond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Array arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel const > tempshared1 ;
  ext::shared_ptr< OneFactorAffineModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Array *v4 ;
  void *argp4 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneFactorAffineModel_discountBond" "', argument " "1"" of type '" "OneFactorAffineModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OneFactorAffineModel_discountBond" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OneFactorAffineModel_discountBond" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    if (ArrayFromSequence(swig_obj[3],&arg4)) {
      ;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OneFactorAffineModel_discountBond" "', argument " "4"" of type '" "Array""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OneFactorAffineModel_discountBond" "', argument " "4"" of type '" "Array""'");
      } else {
        arg4 = *(reinterpret_cast< Array * >(argp4));
      }
    }
  }
  {
    try {
      result = (Real)((OneFactorAffineModel const *)arg1)->discountBond(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneFactorAffineModel_discountBond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel const > tempshared1 ;
  ext::shared_ptr< OneFactorAffineModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneFactorAffineModel_discountBond" "', argument " "1"" of type '" "OneFactorAffineModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OneFactorAffineModel_discountBond" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OneFactorAffineModel_discountBond" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OneFactorAffineModel_discountBond" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((OneFactorAffineModel const *)arg1)->discountBond(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OneFactorAffineModel_discountBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "OneFactorAffineModel_discountBond", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OneFactorAffineModel_discountBond__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              Size size = PySequence_Size(argv[3]);
              if (size == 0) {
                _v = 1;
              } else {
                PyObject* o = PySequence_GetItem(argv[3],0);
                if (PyNumber_Check(o))
                _v = 1;
                else
                _v = 0;
                Py_DECREF(o);
              }
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            return _wrap_OneFactorAffineModel_discountBond__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OneFactorAffineModel_discountBond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OneFactorAffineModel::discountBond(Time,Time,Array) const\n"
    "    OneFactorAffineModel::discountBond(Time,Time,Rate) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OneFactorAffineModel_discount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel const > tempshared1 ;
  ext::shared_ptr< OneFactorAffineModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DiscountFactor result;
  
  if (!SWIG_Python_UnpackTuple(args, "OneFactorAffineModel_discount", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OneFactorAffineModel_discount" "', argument " "1"" of type '" "OneFactorAffineModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OneFactorAffineModel_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (DiscountFactor)((OneFactorAffineModel const *)arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OneFactorAffineModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OneFactorAffineModel *arg1 = (OneFactorAffineModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempshared1 ;
  ext::shared_ptr< OneFactorAffineModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OneFactorAffineModel" "', argument " "1"" of type '" "OneFactorAffineModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OneFactorAffineModel > * >(argp1);
      arg1 = const_cast< OneFactorAffineModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OneFactorAffineModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Vasicek__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real 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 ;
  Vasicek *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vasicek" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vasicek" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vasicek" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vasicek" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Vasicek" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Vasicek *)new Vasicek(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Vasicek > *smartresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vasicek__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Vasicek *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vasicek" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vasicek" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vasicek" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vasicek" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Vasicek *)new Vasicek(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Vasicek > *smartresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vasicek__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Vasicek *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vasicek" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vasicek" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vasicek" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Vasicek *)new Vasicek(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Vasicek > *smartresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vasicek__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Vasicek *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vasicek" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vasicek" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Vasicek *)new Vasicek(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Vasicek > *smartresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vasicek__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  Vasicek *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vasicek" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    try {
      result = (Vasicek *)new Vasicek(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Vasicek > *smartresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vasicek__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Vasicek *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Vasicek *)new Vasicek();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Vasicek > *smartresult = result ? new ext::shared_ptr<  Vasicek >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vasicek(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Vasicek", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Vasicek__SWIG_5(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Vasicek__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vasicek__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Vasicek__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Vasicek__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Vasicek__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Vasicek'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Vasicek::Vasicek(Rate,Real,Real,Real,Real)\n"
    "    Vasicek::Vasicek(Rate,Real,Real,Real)\n"
    "    Vasicek::Vasicek(Rate,Real,Real)\n"
    "    Vasicek::Vasicek(Rate,Real)\n"
    "    Vasicek::Vasicek(Rate)\n"
    "    Vasicek::Vasicek()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Vasicek(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Vasicek *arg1 = (Vasicek *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Vasicek > tempshared1 ;
  ext::shared_ptr< Vasicek > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vasicek" "', argument " "1"" of type '" "Vasicek *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Vasicek > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Vasicek > * >(argp1);
      arg1 = const_cast< Vasicek * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Vasicek > * >(argp1);
      arg1 = const_cast< Vasicek * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Vasicek_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Vasicek_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Vasicek_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HullWhite__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  HullWhite *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HullWhite" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HullWhite" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HullWhite" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HullWhite" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (HullWhite *)new HullWhite((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HullWhite > *smartresult = result ? new ext::shared_ptr<  HullWhite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HullWhite__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  HullWhite *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HullWhite" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HullWhite" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HullWhite" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (HullWhite *)new HullWhite((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HullWhite > *smartresult = result ? new ext::shared_ptr<  HullWhite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HullWhite__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  HullWhite *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HullWhite" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HullWhite" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (HullWhite *)new HullWhite((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HullWhite > *smartresult = result ? new ext::shared_ptr<  HullWhite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HullWhite(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HullWhite", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HullWhite__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HullWhite__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_HullWhite__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HullWhite'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HullWhite::HullWhite(Handle< YieldTermStructure > const &,Real,Real)\n"
    "    HullWhite::HullWhite(Handle< YieldTermStructure > const &,Real)\n"
    "    HullWhite::HullWhite(Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HullWhite_convexityBias(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Real 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 *swig_obj[5] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "HullWhite_convexityBias", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "HullWhite_convexityBias" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HullWhite_convexityBias" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HullWhite_convexityBias" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HullWhite_convexityBias" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HullWhite_convexityBias" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Rate)HullWhite::convexityBias(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HullWhite_termStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhite *arg1 = (HullWhite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite const > tempshared1 ;
  ext::shared_ptr< HullWhite const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HullWhite_termStructure" "', argument " "1"" of type '" "HullWhite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const HullWhite > * >(argp1);
      arg1 = const_cast< HullWhite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const HullWhite > * >(argp1);
      arg1 = const_cast< HullWhite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((HullWhite const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HullWhite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HullWhite *arg1 = (HullWhite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  ext::shared_ptr< HullWhite > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HullWhite" "', argument " "1"" of type '" "HullWhite *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HullWhite > * >(argp1);
      arg1 = const_cast< HullWhite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HullWhite > * >(argp1);
      arg1 = const_cast< HullWhite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HullWhite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HullWhite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackKarasinski__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  BlackKarasinski *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackKarasinski" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackKarasinski" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackKarasinski" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackKarasinski" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (BlackKarasinski *)new BlackKarasinski((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackKarasinski > *smartresult = result ? new ext::shared_ptr<  BlackKarasinski >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackKarasinski__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  BlackKarasinski *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackKarasinski" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackKarasinski" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackKarasinski" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (BlackKarasinski *)new BlackKarasinski((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackKarasinski > *smartresult = result ? new ext::shared_ptr<  BlackKarasinski >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackKarasinski__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BlackKarasinski *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackKarasinski" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackKarasinski" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (BlackKarasinski *)new BlackKarasinski((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackKarasinski > *smartresult = result ? new ext::shared_ptr<  BlackKarasinski >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackKarasinski(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackKarasinski", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BlackKarasinski__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BlackKarasinski__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BlackKarasinski__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackKarasinski'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackKarasinski::BlackKarasinski(Handle< YieldTermStructure > const &,Real,Real)\n"
    "    BlackKarasinski::BlackKarasinski(Handle< YieldTermStructure > const &,Real)\n"
    "    BlackKarasinski::BlackKarasinski(Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackKarasinski_termStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackKarasinski *arg1 = (BlackKarasinski *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackKarasinski const > tempshared1 ;
  ext::shared_ptr< BlackKarasinski const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackKarasinski_termStructure" "', argument " "1"" of type '" "BlackKarasinski const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackKarasinski > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackKarasinski > * >(argp1);
      arg1 = const_cast< BlackKarasinski * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackKarasinski > * >(argp1);
      arg1 = const_cast< BlackKarasinski * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((BlackKarasinski const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackKarasinski(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackKarasinski *arg1 = (BlackKarasinski *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackKarasinski > tempshared1 ;
  ext::shared_ptr< BlackKarasinski > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackKarasinski" "', argument " "1"" of type '" "BlackKarasinski *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackKarasinski > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackKarasinski > * >(argp1);
      arg1 = const_cast< BlackKarasinski * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackKarasinski > * >(argp1);
      arg1 = const_cast< BlackKarasinski * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackKarasinski_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackKarasinski_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackKarasinski_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CoxIngersollRoss__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  CoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CoxIngersollRoss" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CoxIngersollRoss" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CoxIngersollRoss" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoxIngersollRoss__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  CoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CoxIngersollRoss" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CoxIngersollRoss" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoxIngersollRoss__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  CoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CoxIngersollRoss" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoxIngersollRoss__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  CoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CoxIngersollRoss" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoxIngersollRoss__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (CoxIngersollRoss *)new CoxIngersollRoss();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  CoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoxIngersollRoss(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CoxIngersollRoss", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CoxIngersollRoss__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CoxIngersollRoss__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CoxIngersollRoss__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CoxIngersollRoss__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_CoxIngersollRoss__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CoxIngersollRoss'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CoxIngersollRoss::CoxIngersollRoss(Rate,Real,Real,Real)\n"
    "    CoxIngersollRoss::CoxIngersollRoss(Rate,Real,Real)\n"
    "    CoxIngersollRoss::CoxIngersollRoss(Rate,Real)\n"
    "    CoxIngersollRoss::CoxIngersollRoss(Rate)\n"
    "    CoxIngersollRoss::CoxIngersollRoss()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoxIngersollRoss_discount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CoxIngersollRoss *arg1 = (CoxIngersollRoss *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CoxIngersollRoss const > tempshared1 ;
  ext::shared_ptr< CoxIngersollRoss const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DiscountFactor result;
  
  if (!SWIG_Python_UnpackTuple(args, "CoxIngersollRoss_discount", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoxIngersollRoss_discount" "', argument " "1"" of type '" "CoxIngersollRoss const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CoxIngersollRoss > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CoxIngersollRoss > * >(argp1);
      arg1 = const_cast< CoxIngersollRoss * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CoxIngersollRoss > * >(argp1);
      arg1 = const_cast< CoxIngersollRoss * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoxIngersollRoss_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (DiscountFactor)((CoxIngersollRoss const *)arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CoxIngersollRoss(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CoxIngersollRoss *arg1 = (CoxIngersollRoss *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CoxIngersollRoss > tempshared1 ;
  ext::shared_ptr< CoxIngersollRoss > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoxIngersollRoss" "', argument " "1"" of type '" "CoxIngersollRoss *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CoxIngersollRoss > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CoxIngersollRoss > * >(argp1);
      arg1 = const_cast< CoxIngersollRoss * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CoxIngersollRoss > * >(argp1);
      arg1 = const_cast< CoxIngersollRoss * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CoxIngersollRoss_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CoxIngersollRoss_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CoxIngersollRoss_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExtendedCoxIngersollRoss__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedCoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedCoxIngersollRoss__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedCoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedCoxIngersollRoss__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedCoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedCoxIngersollRoss__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedCoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedCoxIngersollRoss__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ExtendedCoxIngersollRoss *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (ExtendedCoxIngersollRoss *)new ExtendedCoxIngersollRoss((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExtendedCoxIngersollRoss > *smartresult = result ? new ext::shared_ptr<  ExtendedCoxIngersollRoss >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExtendedCoxIngersollRoss(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExtendedCoxIngersollRoss", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExtendedCoxIngersollRoss__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExtendedCoxIngersollRoss__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ExtendedCoxIngersollRoss__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ExtendedCoxIngersollRoss__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ExtendedCoxIngersollRoss__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExtendedCoxIngersollRoss'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExtendedCoxIngersollRoss::ExtendedCoxIngersollRoss(Handle< YieldTermStructure > const &,Real,Real,Real,Real)\n"
    "    ExtendedCoxIngersollRoss::ExtendedCoxIngersollRoss(Handle< YieldTermStructure > const &,Real,Real,Real)\n"
    "    ExtendedCoxIngersollRoss::ExtendedCoxIngersollRoss(Handle< YieldTermStructure > const &,Real,Real)\n"
    "    ExtendedCoxIngersollRoss::ExtendedCoxIngersollRoss(Handle< YieldTermStructure > const &,Real)\n"
    "    ExtendedCoxIngersollRoss::ExtendedCoxIngersollRoss(Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ExtendedCoxIngersollRoss_discount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExtendedCoxIngersollRoss *arg1 = (ExtendedCoxIngersollRoss *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtendedCoxIngersollRoss const > tempshared1 ;
  ext::shared_ptr< ExtendedCoxIngersollRoss const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DiscountFactor result;
  
  if (!SWIG_Python_UnpackTuple(args, "ExtendedCoxIngersollRoss_discount", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtendedCoxIngersollRoss_discount" "', argument " "1"" of type '" "ExtendedCoxIngersollRoss const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ExtendedCoxIngersollRoss > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ExtendedCoxIngersollRoss > * >(argp1);
      arg1 = const_cast< ExtendedCoxIngersollRoss * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ExtendedCoxIngersollRoss > * >(argp1);
      arg1 = const_cast< ExtendedCoxIngersollRoss * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExtendedCoxIngersollRoss_discount" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (DiscountFactor)((ExtendedCoxIngersollRoss const *)arg1)->discount(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExtendedCoxIngersollRoss(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExtendedCoxIngersollRoss *arg1 = (ExtendedCoxIngersollRoss *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtendedCoxIngersollRoss > tempshared1 ;
  ext::shared_ptr< ExtendedCoxIngersollRoss > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExtendedCoxIngersollRoss" "', argument " "1"" of type '" "ExtendedCoxIngersollRoss *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExtendedCoxIngersollRoss > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExtendedCoxIngersollRoss > * >(argp1);
      arg1 = const_cast< ExtendedCoxIngersollRoss * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExtendedCoxIngersollRoss > * >(argp1);
      arg1 = const_cast< ExtendedCoxIngersollRoss * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExtendedCoxIngersollRoss_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExtendedCoxIngersollRoss_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_G2__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  G2 *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_G2" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_G2" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_G2" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (G2 *)new G2((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2 > *smartresult = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_G2__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  G2 *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_G2" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_G2" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (G2 *)new G2((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2 > *smartresult = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_G2__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  G2 *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_G2" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (G2 *)new G2((Handle< YieldTermStructure > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2 > *smartresult = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_G2__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  G2 *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (G2 *)new G2((Handle< YieldTermStructure > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2 > *smartresult = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_G2__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  G2 *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (G2 *)new G2((Handle< YieldTermStructure > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2 > *smartresult = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_G2__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  G2 *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_G2" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (G2 *)new G2((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2 > *smartresult = result ? new ext::shared_ptr<  G2 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_G2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_G2", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_G2__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_G2__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_G2__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_G2__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_G2__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_G2__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_G2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    G2::G2(Handle< YieldTermStructure > const &,Real,Real,Real,Real,Real)\n"
    "    G2::G2(Handle< YieldTermStructure > const &,Real,Real,Real,Real)\n"
    "    G2::G2(Handle< YieldTermStructure > const &,Real,Real,Real)\n"
    "    G2::G2(Handle< YieldTermStructure > const &,Real,Real)\n"
    "    G2::G2(Handle< YieldTermStructure > const &,Real)\n"
    "    G2::G2(Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_G2_termStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  G2 *arg1 = (G2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 const > tempshared1 ;
  ext::shared_ptr< G2 const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "G2_termStructure" "', argument " "1"" of type '" "G2 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const G2 > * >(argp1);
      arg1 = const_cast< G2 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const G2 > * >(argp1);
      arg1 = const_cast< G2 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< YieldTermStructure > *) &((G2 const *)arg1)->termStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_YieldTermStructure_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_G2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  G2 *arg1 = (G2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  ext::shared_ptr< G2 > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_G2" "', argument " "1"" of type '" "G2 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  G2 > * >(argp1);
      arg1 = const_cast< G2 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  G2 > * >(argp1);
      arg1 = const_cast< G2 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *G2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_G2_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *G2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_JamshidianSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  JamshidianSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JamshidianSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< OneFactorAffineModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_JamshidianSwaptionEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JamshidianSwaptionEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (JamshidianSwaptionEngine *)new JamshidianSwaptionEngine((ext::shared_ptr< OneFactorAffineModel > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JamshidianSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  JamshidianSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JamshidianSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JamshidianSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempshared1 ;
  JamshidianSwaptionEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JamshidianSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< OneFactorAffineModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (JamshidianSwaptionEngine *)new JamshidianSwaptionEngine((ext::shared_ptr< OneFactorAffineModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  JamshidianSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  JamshidianSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_JamshidianSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JamshidianSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_JamshidianSwaptionEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JamshidianSwaptionEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_JamshidianSwaptionEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_JamshidianSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    JamshidianSwaptionEngine::JamshidianSwaptionEngine(ext::shared_ptr< OneFactorAffineModel > const &,Handle< YieldTermStructure > const &)\n"
    "    JamshidianSwaptionEngine::JamshidianSwaptionEngine(ext::shared_ptr< OneFactorAffineModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_JamshidianSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  JamshidianSwaptionEngine *arg1 = (JamshidianSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< JamshidianSwaptionEngine > tempshared1 ;
  ext::shared_ptr< JamshidianSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_JamshidianSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JamshidianSwaptionEngine" "', argument " "1"" of type '" "JamshidianSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  JamshidianSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  JamshidianSwaptionEngine > * >(argp1);
      arg1 = const_cast< JamshidianSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  JamshidianSwaptionEngine > * >(argp1);
      arg1 = const_cast< JamshidianSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JamshidianSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_JamshidianSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *JamshidianSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeSwaptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TreeSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeSwaptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  TreeSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ShortRateModel_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "Handle< ShortRateModel > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "Handle< ShortRateModel > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeSwaptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((Handle< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TreeSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_ShortRateModel_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "Handle< ShortRateModel > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeSwaptionEngine" "', argument " "1"" of type '" "Handle< ShortRateModel > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< ShortRateModel > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TreeSwaptionEngine *)new TreeSwaptionEngine((Handle< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  TreeSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TreeSwaptionEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TreeSwaptionEngine__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TreeSwaptionEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ShortRateModel_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TreeSwaptionEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeSwaptionEngine__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_ShortRateModel_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeSwaptionEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeSwaptionEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TreeSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TreeSwaptionEngine::TreeSwaptionEngine(ext::shared_ptr< ShortRateModel > const &,Size,Handle< YieldTermStructure > const &)\n"
    "    TreeSwaptionEngine::TreeSwaptionEngine(ext::shared_ptr< ShortRateModel > const &,Size)\n"
    "    TreeSwaptionEngine::TreeSwaptionEngine(ext::shared_ptr< ShortRateModel > const &,TimeGrid const &,Handle< YieldTermStructure > const &)\n"
    "    TreeSwaptionEngine::TreeSwaptionEngine(ext::shared_ptr< ShortRateModel > const &,TimeGrid const &)\n"
    "    TreeSwaptionEngine::TreeSwaptionEngine(Handle< ShortRateModel > const &,Size,Handle< YieldTermStructure > const &)\n"
    "    TreeSwaptionEngine::TreeSwaptionEngine(Handle< ShortRateModel > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TreeSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TreeSwaptionEngine *arg1 = (TreeSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TreeSwaptionEngine > tempshared1 ;
  ext::shared_ptr< TreeSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeSwaptionEngine" "', argument " "1"" of type '" "TreeSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TreeSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TreeSwaptionEngine > * >(argp1);
      arg1 = const_cast< TreeSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TreeSwaptionEngine > * >(argp1);
      arg1 = const_cast< TreeSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TreeSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TreeSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TreeSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticCapFloorEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  AnalyticCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< OneFactorAffineModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticCapFloorEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AnalyticCapFloorEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (AnalyticCapFloorEngine *)new AnalyticCapFloorEngine((ext::shared_ptr< OneFactorAffineModel > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticCapFloorEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OneFactorAffineModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< OneFactorAffineModel > tempshared1 ;
  AnalyticCapFloorEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< OneFactorAffineModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< OneFactorAffineModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticCapFloorEngine *)new AnalyticCapFloorEngine((ext::shared_ptr< OneFactorAffineModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AnalyticCapFloorEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AnalyticCapFloorEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnalyticCapFloorEngine__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OneFactorAffineModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AnalyticCapFloorEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AnalyticCapFloorEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AnalyticCapFloorEngine::AnalyticCapFloorEngine(ext::shared_ptr< OneFactorAffineModel > const &,Handle< YieldTermStructure > const &)\n"
    "    AnalyticCapFloorEngine::AnalyticCapFloorEngine(ext::shared_ptr< OneFactorAffineModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticCapFloorEngine *arg1 = (AnalyticCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticCapFloorEngine > tempshared1 ;
  ext::shared_ptr< AnalyticCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticCapFloorEngine" "', argument " "1"" of type '" "AnalyticCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticCapFloorEngine > * >(argp1);
      arg1 = const_cast< AnalyticCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticCapFloorEngine > * >(argp1);
      arg1 = const_cast< AnalyticCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TreeCapFloorEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeCapFloorEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeCapFloorEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCapFloorEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TreeCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeCapFloorEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCapFloorEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeCapFloorEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeCapFloorEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCapFloorEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCapFloorEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCapFloorEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  TreeCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeCapFloorEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCapFloorEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  {
    try {
      result = (TreeCapFloorEngine *)new TreeCapFloorEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  TreeCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCapFloorEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TreeCapFloorEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TreeCapFloorEngine__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TreeCapFloorEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeCapFloorEngine__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeCapFloorEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TreeCapFloorEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TreeCapFloorEngine::TreeCapFloorEngine(ext::shared_ptr< ShortRateModel > const &,Size,Handle< YieldTermStructure > const &)\n"
    "    TreeCapFloorEngine::TreeCapFloorEngine(ext::shared_ptr< ShortRateModel > const &,Size)\n"
    "    TreeCapFloorEngine::TreeCapFloorEngine(ext::shared_ptr< ShortRateModel > const &,TimeGrid const &,Handle< YieldTermStructure > const &)\n"
    "    TreeCapFloorEngine::TreeCapFloorEngine(ext::shared_ptr< ShortRateModel > const &,TimeGrid const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TreeCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TreeCapFloorEngine *arg1 = (TreeCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TreeCapFloorEngine > tempshared1 ;
  ext::shared_ptr< TreeCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeCapFloorEngine" "', argument " "1"" of type '" "TreeCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TreeCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TreeCapFloorEngine > * >(argp1);
      arg1 = const_cast< TreeCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TreeCapFloorEngine > * >(argp1);
      arg1 = const_cast< TreeCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TreeCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TreeCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TreeCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_G2SwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  G2SwaptionEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_G2SwaptionEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_G2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_G2SwaptionEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_G2SwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (G2SwaptionEngine *)new G2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  G2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  G2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_G2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_G2SwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  G2SwaptionEngine *arg1 = (G2SwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< G2SwaptionEngine > tempshared1 ;
  ext::shared_ptr< G2SwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2SwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_G2SwaptionEngine" "', argument " "1"" of type '" "G2SwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  G2SwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  G2SwaptionEngine > * >(argp1);
      arg1 = const_cast< G2SwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  G2SwaptionEngine > * >(argp1);
      arg1 = const_cast< G2SwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *G2SwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_G2SwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *G2SwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdG2SwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdG2SwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdG2SwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdG2SwaptionEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdG2SwaptionEngine" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdG2SwaptionEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdG2SwaptionEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2,arg3,arg4,arg5,arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  Real arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdG2SwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdG2SwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdG2SwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdG2SwaptionEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdG2SwaptionEngine" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdG2SwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdG2SwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdG2SwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdG2SwaptionEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdG2SwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdG2SwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdG2SwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdG2SwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdG2SwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdG2SwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  FdG2SwaptionEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdG2SwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdG2SwaptionEngine *)new FdG2SwaptionEngine((ext::shared_ptr< G2 > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdG2SwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdG2SwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdG2SwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdG2SwaptionEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdG2SwaptionEngine__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdG2SwaptionEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdG2SwaptionEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdG2SwaptionEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdG2SwaptionEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdG2SwaptionEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdG2SwaptionEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdG2SwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &,Size,Size,Size,Size,Real,FdmSchemeDesc const &)\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &,Size,Size,Size,Size,Real)\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &,Size,Size,Size,Size)\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &,Size,Size,Size)\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &,Size,Size)\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &,Size)\n"
    "    FdG2SwaptionEngine::FdG2SwaptionEngine(ext::shared_ptr< G2 > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdG2SwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdG2SwaptionEngine *arg1 = (FdG2SwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdG2SwaptionEngine > tempshared1 ;
  ext::shared_ptr< FdG2SwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdG2SwaptionEngine" "', argument " "1"" of type '" "FdG2SwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdG2SwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdG2SwaptionEngine > * >(argp1);
      arg1 = const_cast< FdG2SwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdG2SwaptionEngine > * >(argp1);
      arg1 = const_cast< FdG2SwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdG2SwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdG2SwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdG2SwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  FdmSchemeDesc *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "6"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg6 = reinterpret_cast< FdmSchemeDesc * >(argp6);
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1,arg2,arg3,arg4,arg5,(FdmSchemeDesc const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHullWhiteSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHullWhiteSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHullWhiteSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHullWhiteSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHullWhiteSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  FdHullWhiteSwaptionEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdHullWhiteSwaptionEngine *)new FdHullWhiteSwaptionEngine((ext::shared_ptr< HullWhite > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdHullWhiteSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  FdHullWhiteSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdHullWhiteSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdHullWhiteSwaptionEngine", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdHullWhiteSwaptionEngine__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdHullWhiteSwaptionEngine__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdHullWhiteSwaptionEngine__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdHullWhiteSwaptionEngine__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdHullWhiteSwaptionEngine__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdHullWhiteSwaptionEngine__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdHullWhiteSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdHullWhiteSwaptionEngine::FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const &,Size,Size,Size,Real,FdmSchemeDesc const &)\n"
    "    FdHullWhiteSwaptionEngine::FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const &,Size,Size,Size,Real)\n"
    "    FdHullWhiteSwaptionEngine::FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const &,Size,Size,Size)\n"
    "    FdHullWhiteSwaptionEngine::FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const &,Size,Size)\n"
    "    FdHullWhiteSwaptionEngine::FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const &,Size)\n"
    "    FdHullWhiteSwaptionEngine::FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdHullWhiteSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdHullWhiteSwaptionEngine *arg1 = (FdHullWhiteSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdHullWhiteSwaptionEngine > tempshared1 ;
  ext::shared_ptr< FdHullWhiteSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdHullWhiteSwaptionEngine" "', argument " "1"" of type '" "FdHullWhiteSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdHullWhiteSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdHullWhiteSwaptionEngine > * >(argp1);
      arg1 = const_cast< FdHullWhiteSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdHullWhiteSwaptionEngine > * >(argp1);
      arg1 = const_cast< FdHullWhiteSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdHullWhiteSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdHullWhiteSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticBSMHullWhiteEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< HullWhite > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< HullWhite > tempshared3 ;
  PyObject *swig_obj[3] ;
  AnalyticBSMHullWhiteEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AnalyticBSMHullWhiteEngine", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AnalyticBSMHullWhiteEngine" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AnalyticBSMHullWhiteEngine" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AnalyticBSMHullWhiteEngine" "', argument " "3"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (AnalyticBSMHullWhiteEngine *)new AnalyticBSMHullWhiteEngine(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< HullWhite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticBSMHullWhiteEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticBSMHullWhiteEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticBSMHullWhiteEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticBSMHullWhiteEngine *arg1 = (AnalyticBSMHullWhiteEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticBSMHullWhiteEngine > tempshared1 ;
  ext::shared_ptr< AnalyticBSMHullWhiteEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticBSMHullWhiteEngine" "', argument " "1"" of type '" "AnalyticBSMHullWhiteEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticBSMHullWhiteEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticBSMHullWhiteEngine > * >(argp1);
      arg1 = const_cast< AnalyticBSMHullWhiteEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticBSMHullWhiteEngine > * >(argp1);
      arg1 = const_cast< AnalyticBSMHullWhiteEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticBSMHullWhiteEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticBSMHullWhiteEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BondPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  BondPrice::Type arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BondPrice *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BondPrice", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BondPrice" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BondPrice" "', argument " "2"" of type '" "BondPrice::Type""'");
  } 
  arg2 = static_cast< BondPrice::Type >(val2);
  {
    try {
      result = (BondPrice *)new BondPrice(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BondPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondPrice_amount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondPrice *arg1 = (BondPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BondPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondPrice_amount" "', argument " "1"" of type '" "BondPrice const *""'"); 
  }
  arg1 = reinterpret_cast< BondPrice * >(argp1);
  {
    try {
      result = (Real)((BondPrice const *)arg1)->amount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondPrice_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondPrice *arg1 = (BondPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BondPrice::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BondPrice, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondPrice_type" "', argument " "1"" of type '" "BondPrice const *""'"); 
  }
  arg1 = reinterpret_cast< BondPrice * >(argp1);
  {
    try {
      result = (BondPrice::Type)((BondPrice const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BondPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondPrice *arg1 = (BondPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BondPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BondPrice" "', argument " "1"" of type '" "BondPrice *""'"); 
  }
  arg1 = reinterpret_cast< BondPrice * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BondPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BondPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BondPrice_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Bond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Leg *arg6 = 0 ;
  unsigned int 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 ;
  int res6 = SWIG_OLDOBJ ;
  Bond *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Bond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Bond" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Bond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Bond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Bond" "', argument " "6"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "6"" of type '" "Leg const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5,(Leg const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  unsigned int 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 ;
  Bond *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Bond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Bond" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Bond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Bond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,(Date const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Bond *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Bond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Bond" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Bond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bond__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Date *arg3 = 0 ;
  Leg *arg4 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Bond *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Bond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Bond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Bond" "', argument " "4"" of type '" "Leg const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "4"" of type '" "Leg const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,(Date const &)*arg3,(Leg const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bond__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Date *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Bond *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Bond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Bond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bond__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Bond *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Bond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Bond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    try {
      result = (Bond *)new Bond(arg1,(Calendar const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Bond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Bond", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Bond__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Bond__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Bond__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Bond__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_Bond__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Bond__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Bond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::Bond(Natural,Calendar const &,Real,Date const &,Date const &,Leg const &)\n"
    "    Bond::Bond(Natural,Calendar const &,Real,Date const &,Date const &)\n"
    "    Bond::Bond(Natural,Calendar const &,Real,Date const &)\n"
    "    Bond::Bond(Natural,Calendar const &,Date const &,Leg const &)\n"
    "    Bond::Bond(Natural,Calendar const &,Date const &)\n"
    "    Bond::Bond(Natural,Calendar const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_nextCouponRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_nextCouponRate" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_nextCouponRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_nextCouponRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)(arg1)->nextCouponRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_nextCouponRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Rate result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_nextCouponRate" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->nextCouponRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_nextCouponRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_nextCouponRate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_nextCouponRate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Bond_nextCouponRate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_nextCouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::nextCouponRate(Date const &)\n"
    "    Bond::nextCouponRate()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_previousCouponRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_previousCouponRate" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_previousCouponRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_previousCouponRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Rate)(arg1)->previousCouponRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_previousCouponRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Rate result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_previousCouponRate" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)(arg1)->previousCouponRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_previousCouponRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_previousCouponRate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_previousCouponRate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Bond_previousCouponRate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_previousCouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::previousCouponRate(Date const &)\n"
    "    Bond::previousCouponRate()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_settlementDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Natural result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_settlementDays" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Natural)((Bond const *)arg1)->settlementDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_settlementDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_settlementDate" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_settlementDate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_settlementDate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (arg1)->settlementDate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_settlementDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_settlementDate" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->settlementDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_settlementDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_settlementDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_settlementDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Bond_settlementDate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_settlementDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::settlementDate(Date)\n"
    "    Bond::settlementDate()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_startDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_startDate" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_maturityDate" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_issueDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_issueDate" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->issueDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_cashflows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_cashflows" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->cashflows();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_redemptions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_redemptions" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->redemptions();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_redemption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CashFlow > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_redemption" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->redemption();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_calendar" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_notionals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_notionals" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Bond const *)arg1)->notionals();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_notional__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_notional" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_notional" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_notional" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Real)((Bond const *)arg1)->notional(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_notional__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_notional" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Bond const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_notional(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_notional", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_notional__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Bond_notional__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_notional'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::notional(Date) const\n"
    "    Bond::notional() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_cleanPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_cleanPrice" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->cleanPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_cleanPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_cleanPrice" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_cleanPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_cleanPrice" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_cleanPrice" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Bond_cleanPrice" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_cleanPrice" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    try {
      result = (Real)(arg1)->cleanPrice(arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_cleanPrice__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_cleanPrice" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_cleanPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_cleanPrice" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_cleanPrice" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)(arg1)->cleanPrice(arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_cleanPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_cleanPrice", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_cleanPrice__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Bond_cleanPrice__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Bond_cleanPrice__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_cleanPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::cleanPrice()\n"
    "    Bond::cleanPrice(Rate,DayCounter const &,Compounding,Frequency,Date const &)\n"
    "    Bond::cleanPrice(Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_dirtyPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_dirtyPrice" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->dirtyPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_dirtyPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_dirtyPrice" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_dirtyPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_dirtyPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_dirtyPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_dirtyPrice" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_dirtyPrice" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Bond_dirtyPrice" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_dirtyPrice" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    try {
      result = (Real)(arg1)->dirtyPrice(arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_dirtyPrice__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_dirtyPrice" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_dirtyPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_dirtyPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_dirtyPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_dirtyPrice" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_dirtyPrice" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)(arg1)->dirtyPrice(arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_dirtyPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_dirtyPrice", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_dirtyPrice__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Bond_dirtyPrice__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Bond_dirtyPrice__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_dirtyPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::dirtyPrice()\n"
    "    Bond::dirtyPrice(Rate,DayCounter const &,Compounding,Frequency,Date const &)\n"
    "    Bond::dirtyPrice(Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_bondYield" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (Real)(arg1)->yield((DayCounter const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_bondYield" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)(arg1)->yield((DayCounter const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  DayCounter *arg2 = 0 ;
  Compounding arg3 ;
  Frequency arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "2"" of type '" "DayCounter const &""'"); 
  }
  arg2 = reinterpret_cast< DayCounter * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "Compounding""'");
  } 
  arg3 = static_cast< Compounding >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = (Real)(arg1)->yield((DayCounter const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real arg7 ;
  Size arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Bond_bondYield" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Bond_bondYield" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  {
    try {
      result = (Real)(arg1)->yield(arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Bond_bondYield" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)(arg1)->yield(arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Date const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "6"" of type '" "Date const &""'"); 
  }
  arg6 = reinterpret_cast< Date * >(argp6);
  {
    try {
      result = (Real)(arg1)->yield(arg2,(DayCounter const &)*arg3,arg4,arg5,(Date const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_bondYield" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Bond_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Bond_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)(arg1)->yield(arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_bondYield(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_bondYield", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Bond_bondYield__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Bond_bondYield__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Bond_bondYield__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Bond_bondYield__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Bond_bondYield__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Bond_bondYield__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Bond_bondYield__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_bondYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::yield(DayCounter const &,Compounding,Frequency,Real,Size)\n"
    "    Bond::yield(DayCounter const &,Compounding,Frequency,Real)\n"
    "    Bond::yield(DayCounter const &,Compounding,Frequency)\n"
    "    Bond::yield(Real,DayCounter const &,Compounding,Frequency,Date const &,Real,Size)\n"
    "    Bond::yield(Real,DayCounter const &,Compounding,Frequency,Date const &,Real)\n"
    "    Bond::yield(Real,DayCounter const &,Compounding,Frequency,Date const &)\n"
    "    Bond::yield(Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_accruedAmount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_accruedAmount" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Bond_accruedAmount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Bond_accruedAmount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)(arg1)->accruedAmount((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_accruedAmount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_accruedAmount" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->accruedAmount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_accruedAmount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_accruedAmount", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_accruedAmount__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Bond_accruedAmount__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_accruedAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::accruedAmount(Date const &)\n"
    "    Bond::accruedAmount()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Bond_settlementValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_settlementValue" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Bond const *)arg1)->settlementValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_settlementValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  ext::shared_ptr< Bond const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Bond_settlementValue" "', argument " "1"" of type '" "Bond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Bond_settlementValue" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((Bond const *)arg1)->settlementValue(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Bond_settlementValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Bond_settlementValue", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bond_settlementValue__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Bond_settlementValue__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Bond_settlementValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Bond::settlementValue() const\n"
    "    Bond::settlementValue(Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Bond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = (Bond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  ext::shared_ptr< Bond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Bond" "', argument " "1"" of type '" "Bond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Bond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Bond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_simplifyNotificationGraph__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Bond &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Bond &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simplifyNotificationGraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      simplifyNotificationGraph(*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplifyNotificationGraph__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Bond &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simplifyNotificationGraph" "', argument " "1"" of type '" "Bond &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr<  Bond > * >(argp1)->get());
    }
  }
  {
    try {
      simplifyNotificationGraph(*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplifyNotificationGraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "simplifyNotificationGraph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_simplifyNotificationGraph__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_simplifyNotificationGraph__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_simplifyNotificationGraph__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_simplifyNotificationGraph__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'simplifyNotificationGraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    simplifyNotificationGraph(Swap &,bool)\n"
    "    simplifyNotificationGraph(Swap &)\n"
    "    simplifyNotificationGraph(Bond &,bool)\n"
    "    simplifyNotificationGraph(Bond &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cleanPriceFromZSpread__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanPriceFromZSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cleanPriceFromZSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cleanPriceFromZSpread" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cleanPriceFromZSpread" "', argument " "3"" of type '" "Spread""'");
  } 
  arg3 = static_cast< Spread >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cleanPriceFromZSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cleanPriceFromZSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cleanPriceFromZSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cleanPriceFromZSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cleanPriceFromZSpread" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cleanPriceFromZSpread" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (Real)cleanPriceFromZSpread((Bond const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanPriceFromZSpread__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Spread arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanPriceFromZSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cleanPriceFromZSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cleanPriceFromZSpread" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cleanPriceFromZSpread" "', argument " "3"" of type '" "Spread""'");
  } 
  arg3 = static_cast< Spread >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cleanPriceFromZSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cleanPriceFromZSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cleanPriceFromZSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cleanPriceFromZSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Real)cleanPriceFromZSpread((Bond const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanPriceFromZSpread(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cleanPriceFromZSpread", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_cleanPriceFromZSpread__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_cleanPriceFromZSpread__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cleanPriceFromZSpread'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    cleanPriceFromZSpread(Bond const &,ext::shared_ptr< YieldTermStructure > const &,Spread,DayCounter const &,Compounding,Frequency,Date const &)\n"
    "    cleanPriceFromZSpread(Bond const &,ext::shared_ptr< YieldTermStructure > const &,Spread,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sinkingSchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Frequency *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 ;
  Frequency temp3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  Schedule result;
  
  if (!SWIG_Python_UnpackTuple(args, "sinkingSchedule", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sinkingSchedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sinkingSchedule" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sinkingSchedule" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sinkingSchedule" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int (swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sinkingSchedule" "', argument " "3"" of type '" "Frequency const &""'");
  } else {
    temp3 = static_cast< Frequency >(val3);
    arg3 = &temp3;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sinkingSchedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sinkingSchedule" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = QuantLib::sinkingSchedule((Date const &)*arg1,(Period const &)*arg2,(enum Frequency const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Schedule(result)), SWIGTYPE_p_Schedule, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sinkingNotionals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Frequency *arg2 = 0 ;
  Rate arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  Frequency temp2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "sinkingNotionals", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sinkingNotionals" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sinkingNotionals" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sinkingNotionals" "', argument " "2"" of type '" "Frequency const &""'");
  } else {
    temp2 = static_cast< Frequency >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sinkingNotionals" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sinkingNotionals" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = QuantLib::sinkingNotionals((Period const &)*arg1,(enum Frequency const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCouponBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Date *arg4 = 0 ;
  BusinessDayConvention arg5 = (BusinessDayConvention) QuantLib::Following ;
  Real arg6 = (Real) 100.0 ;
  Date const &arg7_defvalue = Date() ;
  Date *arg7 = (Date *) &arg7_defvalue ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double 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 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"calendar",  (char *)"faceAmount",  (char *)"maturityDate",  (char *)"paymentConvention",  (char *)"redemption",  (char *)"issueDate",  NULL 
  };
  ZeroCouponBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:new_ZeroCouponBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZeroCouponBond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCouponBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponBond" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ZeroCouponBond" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ZeroCouponBond" "', argument " "5"" of type '" "BusinessDayConvention""'");
    } 
    arg5 = static_cast< BusinessDayConvention >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_double(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCouponBond" "', argument " "6"" of type '" "Real""'");
    } 
    arg6 = static_cast< Real >(val6);
  }
  if (obj6) {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ZeroCouponBond" "', argument " "7"" of type '" "Date const &""'"); 
    }
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCouponBond" "', argument " "7"" of type '" "Date const &""'"); 
    }
    arg7 = reinterpret_cast< Date * >(argp7);
  }
  {
    try {
      result = (ZeroCouponBond *)new ZeroCouponBond(arg1,(Calendar const &)*arg2,arg3,(Date const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ZeroCouponBond > *smartresult = result ? new ext::shared_ptr<  ZeroCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ZeroCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroCouponBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroCouponBond *arg1 = (ZeroCouponBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ZeroCouponBond > tempshared1 ;
  ext::shared_ptr< ZeroCouponBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ZeroCouponBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroCouponBond" "', argument " "1"" of type '" "ZeroCouponBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ZeroCouponBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ZeroCouponBond > * >(argp1);
      arg1 = const_cast< ZeroCouponBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ZeroCouponBond > * >(argp1);
      arg1 = const_cast< ZeroCouponBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroCouponBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ZeroCouponBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroCouponBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FixedRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 = (BusinessDayConvention) QuantLib::Following ;
  Real arg7 = (Real) 100.0 ;
  Date arg8 = (Date) Date() ;
  Calendar const &arg9_defvalue = Calendar() ;
  Calendar *arg9 = (Calendar *) &arg9_defvalue ;
  Period const &arg10_defvalue = Period() ;
  Period *arg10 = (Period *) &arg10_defvalue ;
  Calendar const &arg11_defvalue = Calendar() ;
  Calendar *arg11 = (Calendar *) &arg11_defvalue ;
  BusinessDayConvention arg12 = (BusinessDayConvention) Unadjusted ;
  bool arg13 = (bool) false ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"faceAmount",  (char *)"schedule",  (char *)"coupons",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"redemption",  (char *)"issueDate",  (char *)"paymentCalendar",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  FixedRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOO:new_FixedRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FixedRateBond" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
    } 
    arg6 = static_cast< BusinessDayConvention >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBond" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    {
      res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Date,  0  | 0);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Date""'"); 
      }  
      if (!argp8) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "8"" of type '" "Date""'");
      } else {
        Date * temp = reinterpret_cast< Date * >(argp8);
        arg8 = *temp;
        if (SWIG_IsNewObj(res8)) delete temp;
      }
    }
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBond" "', argument " "9"" of type '" "Calendar const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "9"" of type '" "Calendar const &""'"); 
    }
    arg9 = reinterpret_cast< Calendar * >(argp9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "Period const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "10"" of type '" "Period const &""'"); 
    }
    arg10 = reinterpret_cast< Period * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBond" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBond" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    arg11 = reinterpret_cast< Calendar * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FixedRateBond" "', argument " "12"" of type '" "BusinessDayConvention""'");
    } 
    arg12 = static_cast< BusinessDayConvention >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_bool(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_FixedRateBond" "', argument " "13"" of type '" "bool""'");
    } 
    arg13 = static_cast< bool >(val13);
  }
  {
    try {
      result = (FixedRateBond *)new FixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(Calendar const &)*arg9,(Period const &)*arg10,(Calendar const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBond > *smartresult = result ? new ext::shared_ptr<  FixedRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedRateBond_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateBond *arg1 = (FixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateBond const > tempshared1 ;
  ext::shared_ptr< FixedRateBond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateBond_frequency" "', argument " "1"" of type '" "FixedRateBond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FixedRateBond > * >(argp1);
      arg1 = const_cast< FixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FixedRateBond > * >(argp1);
      arg1 = const_cast< FixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)((FixedRateBond const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedRateBond_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateBond *arg1 = (FixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateBond const > tempshared1 ;
  ext::shared_ptr< FixedRateBond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateBond_dayCounter" "', argument " "1"" of type '" "FixedRateBond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FixedRateBond > * >(argp1);
      arg1 = const_cast< FixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FixedRateBond > * >(argp1);
      arg1 = const_cast< FixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FixedRateBond const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateBond *arg1 = (FixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateBond > tempshared1 ;
  ext::shared_ptr< FixedRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedRateBond" "', argument " "1"" of type '" "FixedRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedRateBond > * >(argp1);
      arg1 = const_cast< FixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedRateBond > * >(argp1);
      arg1 = const_cast< FixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AmortizingFixedRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 = (BusinessDayConvention) QuantLib::Following ;
  Date arg7 = (Date) Date() ;
  Period const &arg8_defvalue = Period() ;
  Period *arg8 = (Period *) &arg8_defvalue ;
  Calendar const &arg9_defvalue = Calendar() ;
  Calendar *arg9 = (Calendar *) &arg9_defvalue ;
  BusinessDayConvention arg10 = (BusinessDayConvention) (BusinessDayConvention)Unadjusted ;
  bool arg11 = (bool) false ;
  std::vector< Real,std::allocator< Real > > const &arg12_defvalue = {
    100.0 
  } ;
  std::vector< Real,std::allocator< Real > > *arg12 = (std::vector< Real,std::allocator< Real > > *) &arg12_defvalue ;
  Integer arg13 = (Integer) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"notionals",  (char *)"schedule",  (char *)"coupons",  (char *)"accrualDayCounter",  (char *)"paymentConvention",  (char *)"issueDate",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  (char *)"redemptions",  (char *)"paymentLag",  NULL 
  };
  AmortizingFixedRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOO:new_AmortizingFixedRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AmortizingFixedRateBond" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AmortizingFixedRateBond" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AmortizingFixedRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AmortizingFixedRateBond" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AmortizingFixedRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AmortizingFixedRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
    } 
    arg6 = static_cast< BusinessDayConvention >(val6);
  }
  if (obj6) {
    {
      res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Date,  0  | 0);
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_AmortizingFixedRateBond" "', argument " "7"" of type '" "Date""'"); 
      }  
      if (!argp7) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "7"" of type '" "Date""'");
      } else {
        Date * temp = reinterpret_cast< Date * >(argp7);
        arg7 = *temp;
        if (SWIG_IsNewObj(res7)) delete temp;
      }
    }
  }
  if (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_AmortizingFixedRateBond" "', argument " "8"" of type '" "Period const &""'"); 
    }
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "8"" of type '" "Period const &""'"); 
    }
    arg8 = reinterpret_cast< Period * >(argp8);
  }
  if (obj8) {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_AmortizingFixedRateBond" "', argument " "9"" of type '" "Calendar const &""'"); 
    }
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "9"" of type '" "Calendar const &""'"); 
    }
    arg9 = reinterpret_cast< Calendar * >(argp9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_int(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_AmortizingFixedRateBond" "', argument " "10"" of type '" "BusinessDayConvention""'");
    } 
    arg10 = static_cast< BusinessDayConvention >(val10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_bool(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_AmortizingFixedRateBond" "', argument " "11"" of type '" "bool""'");
    } 
    arg11 = static_cast< bool >(val11);
  }
  if (obj11) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res12 = swig::asptr(obj11, &ptr);
      if (!SWIG_IsOK(res12)) {
        SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_AmortizingFixedRateBond" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFixedRateBond" "', argument " "12"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg12 = ptr;
    }
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_int(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_AmortizingFixedRateBond" "', argument " "13"" of type '" "Integer""'");
    } 
    arg13 = static_cast< Integer >(val13);
  }
  {
    try {
      result = (AmortizingFixedRateBond *)new AmortizingFixedRateBond(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Period const &)*arg8,(Calendar const &)*arg9,arg10,arg11,(std::vector< Real,std::allocator< Real > > const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AmortizingFixedRateBond > *smartresult = result ? new ext::shared_ptr<  AmortizingFixedRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AmortizingFixedRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return NULL;
}


SWIGINTERN PyObject *_wrap_AmortizingFixedRateBond_frequency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmortizingFixedRateBond *arg1 = (AmortizingFixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmortizingFixedRateBond const > tempshared1 ;
  ext::shared_ptr< AmortizingFixedRateBond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Frequency result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmortizingFixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AmortizingFixedRateBond_frequency" "', argument " "1"" of type '" "AmortizingFixedRateBond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AmortizingFixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AmortizingFixedRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AmortizingFixedRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Frequency)((AmortizingFixedRateBond const *)arg1)->frequency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AmortizingFixedRateBond_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmortizingFixedRateBond *arg1 = (AmortizingFixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmortizingFixedRateBond const > tempshared1 ;
  ext::shared_ptr< AmortizingFixedRateBond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmortizingFixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AmortizingFixedRateBond_dayCounter" "', argument " "1"" of type '" "AmortizingFixedRateBond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const AmortizingFixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const AmortizingFixedRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const AmortizingFixedRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((AmortizingFixedRateBond const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AmortizingFixedRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmortizingFixedRateBond *arg1 = (AmortizingFixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmortizingFixedRateBond > tempshared1 ;
  ext::shared_ptr< AmortizingFixedRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmortizingFixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AmortizingFixedRateBond" "', argument " "1"" of type '" "AmortizingFixedRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AmortizingFixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AmortizingFixedRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AmortizingFixedRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AmortizingFixedRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AmortizingFixedRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AmortizingFixedRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AmortizingFloatingRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Size arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 = (BusinessDayConvention) Following ;
  Size arg7 = (Size) Null< Size >() ;
  std::vector< Real,std::allocator< Real > > const &arg8_defvalue = std::vector< Real >(1, 1.0) ;
  std::vector< Real,std::allocator< Real > > *arg8 = (std::vector< Real,std::allocator< Real > > *) &arg8_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg9_defvalue = std::vector< Spread >(1, 0.0) ;
  std::vector< Spread,std::allocator< Spread > > *arg9 = (std::vector< Spread,std::allocator< Spread > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg11_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg11 = (std::vector< Rate,std::allocator< Rate > > *) &arg11_defvalue ;
  bool arg12 = (bool) false ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  Period const &arg14_defvalue = Period() ;
  Period *arg14 = (Period *) &arg14_defvalue ;
  Calendar const &arg15_defvalue = Calendar() ;
  Calendar *arg15 = (Calendar *) &arg15_defvalue ;
  BusinessDayConvention arg16 = (BusinessDayConvention) (BusinessDayConvention)Unadjusted ;
  bool arg17 = (bool) false ;
  std::vector< Real,std::allocator< Real > > const &arg18_defvalue = {
    100.0 
  } ;
  std::vector< Real,std::allocator< Real > > *arg18 = (std::vector< Real,std::allocator< Real > > *) &arg18_defvalue ;
  Integer arg19 = (Integer) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  int res18 = SWIG_OLDOBJ ;
  int val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"notional",  (char *)"schedule",  (char *)"index",  (char *)"accrualDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"inArrears",  (char *)"issueDate",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  (char *)"redemptions",  (char *)"paymentLag",  NULL 
  };
  AmortizingFloatingRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOOOOOOOO:new_AmortizingFloatingRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AmortizingFloatingRateBond" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AmortizingFloatingRateBond" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AmortizingFloatingRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AmortizingFloatingRateBond" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AmortizingFloatingRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AmortizingFloatingRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
    } 
    arg6 = static_cast< BusinessDayConvention >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_size_t(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AmortizingFloatingRateBond" "', argument " "7"" of type '" "Size""'");
    } 
    arg7 = static_cast< Size >(val7);
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_AmortizingFloatingRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_AmortizingFloatingRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_AmortizingFloatingRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res11 = swig::asptr(obj10, &ptr);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_AmortizingFloatingRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg11 = ptr;
    }
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_AmortizingFloatingRateBond" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_AmortizingFloatingRateBond" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  if (obj13) {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_AmortizingFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
    }
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "14"" of type '" "Period const &""'"); 
    }
    arg14 = reinterpret_cast< Period * >(argp14);
  }
  if (obj14) {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_AmortizingFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
    }
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "15"" of type '" "Calendar const &""'"); 
    }
    arg15 = reinterpret_cast< Calendar * >(argp15);
  }
  if (obj15) {
    ecode16 = SWIG_AsVal_int(obj15, &val16);
    if (!SWIG_IsOK(ecode16)) {
      SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_AmortizingFloatingRateBond" "', argument " "16"" of type '" "BusinessDayConvention""'");
    } 
    arg16 = static_cast< BusinessDayConvention >(val16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_bool(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_AmortizingFloatingRateBond" "', argument " "17"" of type '" "bool""'");
    } 
    arg17 = static_cast< bool >(val17);
  }
  if (obj17) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res18 = swig::asptr(obj17, &ptr);
      if (!SWIG_IsOK(res18)) {
        SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_AmortizingFloatingRateBond" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingFloatingRateBond" "', argument " "18"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg18 = ptr;
    }
  }
  if (obj18) {
    ecode19 = SWIG_AsVal_int(obj18, &val19);
    if (!SWIG_IsOK(ecode19)) {
      SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_AmortizingFloatingRateBond" "', argument " "19"" of type '" "Integer""'");
    } 
    arg19 = static_cast< Integer >(val19);
  }
  {
    try {
      result = (AmortizingFloatingRateBond *)new AmortizingFloatingRateBond(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real,std::allocator< Real > > const &)*arg8,(std::vector< Spread,std::allocator< Spread > > const &)*arg9,(std::vector< Rate,std::allocator< Rate > > const &)*arg10,(std::vector< Rate,std::allocator< Rate > > const &)*arg11,arg12,(Date const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15,arg16,arg17,(std::vector< Real,std::allocator< Real > > const &)*arg18,arg19);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AmortizingFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  AmortizingFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AmortizingFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  if (SWIG_IsNewObj(res18)) delete arg18;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  if (SWIG_IsNewObj(res18)) delete arg18;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AmortizingFloatingRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmortizingFloatingRateBond *arg1 = (AmortizingFloatingRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmortizingFloatingRateBond > tempshared1 ;
  ext::shared_ptr< AmortizingFloatingRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmortizingFloatingRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AmortizingFloatingRateBond" "', argument " "1"" of type '" "AmortizingFloatingRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AmortizingFloatingRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AmortizingFloatingRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFloatingRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AmortizingFloatingRateBond > * >(argp1);
      arg1 = const_cast< AmortizingFloatingRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AmortizingFloatingRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AmortizingFloatingRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AmortizingFloatingRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FloatingRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 = (BusinessDayConvention) Following ;
  Size arg7 = (Size) Null< Size >() ;
  std::vector< Real,std::allocator< Real > > const &arg8_defvalue = std::vector< Real >() ;
  std::vector< Real,std::allocator< Real > > *arg8 = (std::vector< Real,std::allocator< Real > > *) &arg8_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg9_defvalue = std::vector< Spread >() ;
  std::vector< Spread,std::allocator< Spread > > *arg9 = (std::vector< Spread,std::allocator< Spread > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg11_defvalue = std::vector< Rate >() ;
  std::vector< Rate,std::allocator< Rate > > *arg11 = (std::vector< Rate,std::allocator< Rate > > *) &arg11_defvalue ;
  bool arg12 = (bool) false ;
  Real arg13 = (Real) 100.0 ;
  Date const &arg14_defvalue = Date() ;
  Date *arg14 = (Date *) &arg14_defvalue ;
  Period const &arg15_defvalue = Period() ;
  Period *arg15 = (Period *) &arg15_defvalue ;
  Calendar const &arg16_defvalue = Calendar() ;
  Calendar *arg16 = (Calendar *) &arg16_defvalue ;
  BusinessDayConvention arg17 = (BusinessDayConvention) Unadjusted ;
  bool arg18 = (bool) false ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"faceAmount",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"inArrears",  (char *)"redemption",  (char *)"issueDate",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  FloatingRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOOOOOOO:new_FloatingRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatingRateBond" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatingRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatingRateBond" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FloatingRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatingRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
    } 
    arg6 = static_cast< BusinessDayConvention >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_size_t(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FloatingRateBond" "', argument " "7"" of type '" "Size""'");
    } 
    arg7 = static_cast< Size >(val7);
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FloatingRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FloatingRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatingRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res11 = swig::asptr(obj10, &ptr);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FloatingRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg11 = ptr;
    }
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatingRateBond" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_double(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_FloatingRateBond" "', argument " "13"" of type '" "Real""'");
    } 
    arg13 = static_cast< Real >(val13);
  }
  if (obj13) {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_FloatingRateBond" "', argument " "14"" of type '" "Date const &""'"); 
    }
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "14"" of type '" "Date const &""'"); 
    }
    arg14 = reinterpret_cast< Date * >(argp14);
  }
  if (obj14) {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_FloatingRateBond" "', argument " "15"" of type '" "Period const &""'"); 
    }
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "15"" of type '" "Period const &""'"); 
    }
    arg15 = reinterpret_cast< Period * >(argp15);
  }
  if (obj15) {
    res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatingRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    if (!argp16) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatingRateBond" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    arg16 = reinterpret_cast< Calendar * >(argp16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_int(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_FloatingRateBond" "', argument " "17"" of type '" "BusinessDayConvention""'");
    } 
    arg17 = static_cast< BusinessDayConvention >(val17);
  }
  if (obj17) {
    ecode18 = SWIG_AsVal_bool(obj17, &val18);
    if (!SWIG_IsOK(ecode18)) {
      SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_FloatingRateBond" "', argument " "18"" of type '" "bool""'");
    } 
    arg18 = static_cast< bool >(val18);
  }
  {
    try {
      result = (FloatingRateBond *)new FloatingRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real,std::allocator< Real > > const &)*arg8,(std::vector< Spread,std::allocator< Spread > > const &)*arg9,(std::vector< Rate,std::allocator< Rate > > const &)*arg10,(std::vector< Rate,std::allocator< Rate > > const &)*arg11,arg12,arg13,(Date const &)*arg14,(Period const &)*arg15,(Calendar const &)*arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatingRateBond > *smartresult = result ? new ext::shared_ptr<  FloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FloatingRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatingRateBond *arg1 = (FloatingRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatingRateBond > tempshared1 ;
  ext::shared_ptr< FloatingRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatingRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatingRateBond" "', argument " "1"" of type '" "FloatingRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatingRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatingRateBond > * >(argp1);
      arg1 = const_cast< FloatingRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatingRateBond > * >(argp1);
      arg1 = const_cast< FloatingRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloatingRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FloatingRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FloatingRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CmsRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Natural arg7 ;
  std::vector< Real,std::allocator< Real > > *arg8 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg9 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg11 = 0 ;
  bool arg12 = (bool) false ;
  Real arg13 = (Real) 100.0 ;
  Date const &arg14_defvalue = Date() ;
  Date *arg14 = (Date *) &arg14_defvalue ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  bool val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 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 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"faceAmount",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"inArrears",  (char *)"redemption",  (char *)"issueDate",  NULL 
  };
  CmsRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOO|OOO:new_CmsRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CmsRateBond" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CmsRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CmsRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CmsRateBond" "', argument " "4"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CmsRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CmsRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CmsRateBond" "', argument " "7"" of type '" "Natural""'");
  } 
  arg7 = static_cast< Natural >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(obj7, &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CmsRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg8 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CmsRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(obj9, &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CmsRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg10 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res11 = swig::asptr(obj10, &ptr);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CmsRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg11 = ptr;
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CmsRateBond" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_double(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_CmsRateBond" "', argument " "13"" of type '" "Real""'");
    } 
    arg13 = static_cast< Real >(val13);
  }
  if (obj13) {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CmsRateBond" "', argument " "14"" of type '" "Date const &""'"); 
    }
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CmsRateBond" "', argument " "14"" of type '" "Date const &""'"); 
    }
    arg14 = reinterpret_cast< Date * >(argp14);
  }
  {
    try {
      result = (CmsRateBond *)new CmsRateBond(arg1,arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real,std::allocator< Real > > const &)*arg8,(std::vector< Spread,std::allocator< Spread > > const &)*arg9,(std::vector< Rate,std::allocator< Rate > > const &)*arg10,(std::vector< Rate,std::allocator< Rate > > const &)*arg11,arg12,arg13,(Date const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CmsRateBond > *smartresult = result ? new ext::shared_ptr<  CmsRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CmsRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CmsRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CmsRateBond *arg1 = (CmsRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CmsRateBond > tempshared1 ;
  ext::shared_ptr< CmsRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CmsRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CmsRateBond" "', argument " "1"" of type '" "CmsRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CmsRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CmsRateBond > * >(argp1);
      arg1 = const_cast< CmsRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CmsRateBond > * >(argp1);
      arg1 = const_cast< CmsRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CmsRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CmsRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CmsRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AmortizingCmsRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Schedule *arg3 = 0 ;
  ext::shared_ptr< SwapIndex > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 = (BusinessDayConvention) Following ;
  Natural arg7 = (Natural) Null< Natural >() ;
  std::vector< Real,std::allocator< Real > > const &arg8_defvalue = {
    1.0 
  } ;
  std::vector< Real,std::allocator< Real > > *arg8 = (std::vector< Real,std::allocator< Real > > *) &arg8_defvalue ;
  std::vector< Spread,std::allocator< Spread > > const &arg9_defvalue = {
    0.0 
  } ;
  std::vector< Spread,std::allocator< Spread > > *arg9 = (std::vector< Spread,std::allocator< Spread > > *) &arg9_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg10_defvalue = {
    
  } ;
  std::vector< Rate,std::allocator< Rate > > *arg10 = (std::vector< Rate,std::allocator< Rate > > *) &arg10_defvalue ;
  std::vector< Rate,std::allocator< Rate > > const &arg11_defvalue = {
    
  } ;
  std::vector< Rate,std::allocator< Rate > > *arg11 = (std::vector< Rate,std::allocator< Rate > > *) &arg11_defvalue ;
  bool arg12 = (bool) false ;
  Date const &arg13_defvalue = Date() ;
  Date *arg13 = (Date *) &arg13_defvalue ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  int res11 = SWIG_OLDOBJ ;
  bool 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 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"notionals",  (char *)"schedule",  (char *)"index",  (char *)"paymentDayCounter",  (char *)"paymentConvention",  (char *)"fixingDays",  (char *)"gearings",  (char *)"spreads",  (char *)"caps",  (char *)"floors",  (char *)"inArrears",  (char *)"issueDate",  NULL 
  };
  AmortizingCmsRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOOOOOO:new_AmortizingCmsRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AmortizingCmsRateBond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AmortizingCmsRateBond" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_AmortizingCmsRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_AmortizingCmsRateBond" "', argument " "4"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AmortizingCmsRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_AmortizingCmsRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
    } 
    arg6 = static_cast< BusinessDayConvention >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_AmortizingCmsRateBond" "', argument " "7"" of type '" "Natural""'");
    } 
    arg7 = static_cast< Natural >(val7);
  }
  if (obj7) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_AmortizingCmsRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "8"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  if (obj8) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_AmortizingCmsRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "9"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_AmortizingCmsRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "10"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      res11 = swig::asptr(obj10, &ptr);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_AmortizingCmsRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "11"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
      }
      arg11 = ptr;
    }
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_bool(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_AmortizingCmsRateBond" "', argument " "12"" of type '" "bool""'");
    } 
    arg12 = static_cast< bool >(val12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_AmortizingCmsRateBond" "', argument " "13"" of type '" "Date const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AmortizingCmsRateBond" "', argument " "13"" of type '" "Date const &""'"); 
    }
    arg13 = reinterpret_cast< Date * >(argp13);
  }
  {
    try {
      result = (AmortizingCmsRateBond *)new AmortizingCmsRateBond(arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(Schedule const &)*arg3,(ext::shared_ptr< SwapIndex > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(std::vector< Real,std::allocator< Real > > const &)*arg8,(std::vector< Spread,std::allocator< Spread > > const &)*arg9,(std::vector< Rate,std::allocator< Rate > > const &)*arg10,(std::vector< Rate,std::allocator< Rate > > const &)*arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AmortizingCmsRateBond > *smartresult = result ? new ext::shared_ptr<  AmortizingCmsRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AmortizingCmsRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res8)) delete arg8;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AmortizingCmsRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AmortizingCmsRateBond *arg1 = (AmortizingCmsRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AmortizingCmsRateBond > tempshared1 ;
  ext::shared_ptr< AmortizingCmsRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AmortizingCmsRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AmortizingCmsRateBond" "', argument " "1"" of type '" "AmortizingCmsRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AmortizingCmsRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AmortizingCmsRateBond > * >(argp1);
      arg1 = const_cast< AmortizingCmsRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AmortizingCmsRateBond > * >(argp1);
      arg1 = const_cast< AmortizingCmsRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AmortizingCmsRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AmortizingCmsRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AmortizingCmsRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DiscountingBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  DiscountingBondEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountingBondEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountingBondEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    try {
      result = (DiscountingBondEngine *)new DiscountingBondEngine((Handle< YieldTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DiscountingBondEngine > *smartresult = result ? new ext::shared_ptr<  DiscountingBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DiscountingBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DiscountingBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DiscountingBondEngine *arg1 = (DiscountingBondEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DiscountingBondEngine > tempshared1 ;
  ext::shared_ptr< DiscountingBondEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DiscountingBondEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscountingBondEngine" "', argument " "1"" of type '" "DiscountingBondEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DiscountingBondEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DiscountingBondEngine > * >(argp1);
      arg1 = const_cast< DiscountingBondEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DiscountingBondEngine > * >(argp1);
      arg1 = const_cast< DiscountingBondEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscountingBondEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DiscountingBondEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiscountingBondEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Callability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondPrice *arg1 = 0 ;
  Callability::Type arg2 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Callability *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Callability", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BondPrice,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Callability" "', argument " "1"" of type '" "BondPrice const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Callability" "', argument " "1"" of type '" "BondPrice const &""'"); 
  }
  arg1 = reinterpret_cast< BondPrice * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Callability" "', argument " "2"" of type '" "Callability::Type""'");
  } 
  arg2 = static_cast< Callability::Type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Callability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Callability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Callability *)new Callability((BondPrice const &)*arg1,arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Callability > *smartresult = result ? new ext::shared_ptr<  Callability >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Callability_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callability_price(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Callability *arg1 = (Callability *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Callability const > tempshared1 ;
  ext::shared_ptr< Callability const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BondPrice *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callability_price" "', argument " "1"" of type '" "Callability const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      arg1 = const_cast< Callability * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      arg1 = const_cast< Callability * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BondPrice *) &((Callability const *)arg1)->price();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BondPrice, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callability_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Callability *arg1 = (Callability *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Callability const > tempshared1 ;
  ext::shared_ptr< Callability const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Callability::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callability_type" "', argument " "1"" of type '" "Callability const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      arg1 = const_cast< Callability * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      arg1 = const_cast< Callability * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Callability::Type)((Callability const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Callability_date(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Callability *arg1 = (Callability *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Callability const > tempshared1 ;
  ext::shared_ptr< Callability const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Callability_date" "', argument " "1"" of type '" "Callability const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      arg1 = const_cast< Callability * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Callability > * >(argp1);
      arg1 = const_cast< Callability * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Callability const *)arg1)->date();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Callability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Callability *arg1 = (Callability *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Callability > tempshared1 ;
  ext::shared_ptr< Callability > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Callability" "', argument " "1"" of type '" "Callability *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Callability > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Callability > * >(argp1);
      arg1 = const_cast< Callability * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Callability > * >(argp1);
      arg1 = const_cast< Callability * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Callability_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Callability_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Callability_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SoftCallability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondPrice *arg1 = 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SoftCallability *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SoftCallability", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_BondPrice,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SoftCallability" "', argument " "1"" of type '" "BondPrice const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SoftCallability" "', argument " "1"" of type '" "BondPrice const &""'"); 
  }
  arg1 = reinterpret_cast< BondPrice * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SoftCallability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SoftCallability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SoftCallability" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (SoftCallability *)new SoftCallability((BondPrice const &)*arg1,(Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SoftCallability > *smartresult = result ? new ext::shared_ptr<  SoftCallability >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SoftCallability_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SoftCallability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SoftCallability *arg1 = (SoftCallability *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SoftCallability > tempshared1 ;
  ext::shared_ptr< SoftCallability > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SoftCallability_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SoftCallability" "', argument " "1"" of type '" "SoftCallability *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SoftCallability > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SoftCallability > * >(argp1);
      arg1 = const_cast< SoftCallability * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SoftCallability > * >(argp1);
      arg1 = const_cast< SoftCallability * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SoftCallability_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SoftCallability_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SoftCallability_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CallabilitySchedule_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< Callability > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____bool__((std::vector< ext::shared_ptr< Callability > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____len__((std::vector< ext::shared_ptr< Callability > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CallabilitySchedule___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CallabilitySchedule___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CallabilitySchedule___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallabilitySchedule___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallabilitySchedule___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CallabilitySchedule___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CallabilitySchedule___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::__setslice__(std::vector< ext::shared_ptr< Callability > >::difference_type,std::vector< ext::shared_ptr< Callability > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Callability > >::__setslice__(std::vector< ext::shared_ptr< Callability > >::difference_type,std::vector< ext::shared_ptr< Callability > >::difference_type,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CallabilitySchedule___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallabilitySchedule___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallabilitySchedule___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CallabilitySchedule___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CallabilitySchedule___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::__delitem__(std::vector< ext::shared_ptr< Callability > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Callability > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Callability > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< Callability > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Callability > *smartresult = *result ? new ext::shared_ptr<  Callability >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Callability_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Callability > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CallabilitySchedule___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CallabilitySchedule___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Callability > >::__getitem__(std::vector< ext::shared_ptr< Callability > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallabilitySchedule___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Callability > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CallabilitySchedule___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CallabilitySchedule___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CallabilitySchedule___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)\n"
    "    std::vector< ext::shared_ptr< Callability > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Callability > >::__setitem__(std::vector< ext::shared_ptr< Callability > >::difference_type,std::vector< ext::shared_ptr< Callability > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Callability > *smartresult = result ? new ext::shared_ptr<  Callability >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Callability_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CallabilitySchedule_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__append(arg1,(ext::shared_ptr< Callability > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CallabilitySchedule__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *)new std::vector< ext::shared_ptr< Callability > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CallabilitySchedule__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CallabilitySchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallabilitySchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *)new std::vector< ext::shared_ptr< Callability > >((std::vector< ext::shared_ptr< Callability > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< Callability > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Callability > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CallabilitySchedule_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallabilitySchedule_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< Callability > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Callability > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< Callability > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Callability_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CallabilitySchedule__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CallabilitySchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *)new std::vector< ext::shared_ptr< Callability > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< Callability > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Callability > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< Callability > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_CallabilitySchedule_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_CallabilitySchedule_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::erase(std::vector< ext::shared_ptr< Callability > >::iterator)\n"
    "    std::vector< ext::shared_ptr< Callability > >::erase(std::vector< ext::shared_ptr< Callability > >::iterator,std::vector< ext::shared_ptr< Callability > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CallabilitySchedule__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > >::size_type arg1 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< Callability > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CallabilitySchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CallabilitySchedule" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > > *)new std::vector< ext::shared_ptr< Callability > >(arg1,(std::vector< ext::shared_ptr< Callability > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CallabilitySchedule(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CallabilitySchedule", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CallabilitySchedule__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CallabilitySchedule__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CallabilitySchedule__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CallabilitySchedule__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CallabilitySchedule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::vector()\n"
    "    std::vector< ext::shared_ptr< Callability > >::vector(std::vector< ext::shared_ptr< Callability > > const &)\n"
    "    std::vector< ext::shared_ptr< Callability > >::vector(std::vector< ext::shared_ptr< Callability > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Callability > >::vector(std::vector< ext::shared_ptr< Callability > >::size_type,std::vector< ext::shared_ptr< Callability > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CallabilitySchedule_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< Callability > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > >::value_type *) &((std::vector< ext::shared_ptr< Callability > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Callability > *smartresult = *result ? new ext::shared_ptr<  Callability >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Callability_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Callability > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability > >::value_type *) &((std::vector< ext::shared_ptr< Callability > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Callability > *smartresult = *result ? new ext::shared_ptr<  Callability >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Callability_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Callability > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallabilitySchedule_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< Callability > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallabilitySchedule_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< Callability > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CallabilitySchedule_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CallabilitySchedule_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::resize(std::vector< ext::shared_ptr< Callability > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Callability > >::resize(std::vector< ext::shared_ptr< Callability > >::size_type,std::vector< ext::shared_ptr< Callability > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< Callability > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallabilitySchedule_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Callability > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Callability > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Callability > >::size_type arg3 ;
  std::vector< ext::shared_ptr< Callability > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< Callability > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CallabilitySchedule_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CallabilitySchedule_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Callability_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallabilitySchedule_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Callability > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< Callability > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Callability_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< Callability > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallabilitySchedule_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CallabilitySchedule_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Callability > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Callability_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CallabilitySchedule_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallabilitySchedule_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Callability > >::insert(std::vector< ext::shared_ptr< Callability > >::iterator,std::vector< ext::shared_ptr< Callability > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< Callability > >::insert(std::vector< ext::shared_ptr< Callability > >::iterator,std::vector< ext::shared_ptr< Callability > >::size_type,std::vector< ext::shared_ptr< Callability > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  std::vector< ext::shared_ptr< Callability > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CallabilitySchedule_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallabilitySchedule_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Callability > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Callability > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallabilitySchedule_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallabilitySchedule_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Callability > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CallabilitySchedule(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Callability > > *arg1 = (std::vector< ext::shared_ptr< Callability > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallabilitySchedule" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Callability > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Callability > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CallabilitySchedule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Callability_t_std__allocatorT_ext__shared_ptrT_Callability_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CallabilitySchedule_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CallableBond_callability(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond const > tempshared1 ;
  ext::shared_ptr< CallableBond const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_callability" "', argument " "1"" of type '" "CallableBond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *) &((CallableBond const *)arg1)->callability();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_impliedVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  BondPrice *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Size arg5 ;
  Volatility arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond const > tempshared1 ;
  ext::shared_ptr< CallableBond const > *smartarg1 = 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 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  Volatility result;
  
  if (!SWIG_Python_UnpackTuple(args, "CallableBond_impliedVolatility", 7, 7, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_impliedVolatility" "', argument " "1"" of type '" "CallableBond const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_BondPrice,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CallableBond_impliedVolatility" "', argument " "2"" of type '" "BondPrice const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_impliedVolatility" "', argument " "2"" of type '" "BondPrice const &""'"); 
  }
  arg2 = reinterpret_cast< BondPrice * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CallableBond_impliedVolatility" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_impliedVolatility" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CallableBond_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)((CallableBond const *)arg1)->impliedVolatility((BondPrice const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_OAS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Size arg9 ;
  Spread arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Real result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_OAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_OAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_OAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_OAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CallableBond_OAS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CallableBond_OAS" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CallableBond_OAS" "', argument " "10"" of type '" "Spread""'");
  } 
  arg10 = static_cast< Spread >(val10);
  {
    try {
      result = (Real)(arg1)->OAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_OAS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Size arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_OAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_OAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_OAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_OAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CallableBond_OAS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CallableBond_OAS" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (Real)(arg1)->OAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_OAS__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_OAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_OAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_OAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_OAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CallableBond_OAS" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Real)(arg1)->OAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_OAS__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_OAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_OAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_OAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_OAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (Real)(arg1)->OAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_OAS__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_OAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_OAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_OAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_OAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_OAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Real)(arg1)->OAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_OAS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallableBond_OAS", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CallableBond_OAS__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CallableBond_OAS__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_CallableBond_OAS__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_CallableBond_OAS__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_CallableBond_OAS__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallableBond_OAS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CallableBond::OAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date const &,Real,Size,Spread)\n"
    "    CallableBond::OAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date const &,Real,Size)\n"
    "    CallableBond::OAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date const &,Real)\n"
    "    CallableBond::OAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date const &)\n"
    "    CallableBond::OAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallableBond_cleanPriceOAS__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_cleanPriceOAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_cleanPriceOAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_cleanPriceOAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_cleanPriceOAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_cleanPriceOAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_cleanPriceOAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_cleanPriceOAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_cleanPriceOAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CallableBond_cleanPriceOAS" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_cleanPriceOAS" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Real)(arg1)->cleanPriceOAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_cleanPriceOAS__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_cleanPriceOAS" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_cleanPriceOAS" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_cleanPriceOAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_cleanPriceOAS" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_cleanPriceOAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_cleanPriceOAS" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_cleanPriceOAS" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_cleanPriceOAS" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Real)(arg1)->cleanPriceOAS(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_cleanPriceOAS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallableBond_cleanPriceOAS", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CallableBond_cleanPriceOAS__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_CallableBond_cleanPriceOAS__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallableBond_cleanPriceOAS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CallableBond::cleanPriceOAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date)\n"
    "    CallableBond::cleanPriceOAS(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallableBond_effectiveDuration__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_effectiveDuration" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_effectiveDuration" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_effectiveDuration" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveDuration" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_effectiveDuration" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveDuration" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_effectiveDuration" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_effectiveDuration" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CallableBond_effectiveDuration" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)(arg1)->effectiveDuration(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_effectiveDuration__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_effectiveDuration" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_effectiveDuration" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_effectiveDuration" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveDuration" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_effectiveDuration" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveDuration" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_effectiveDuration" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_effectiveDuration" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Real)(arg1)->effectiveDuration(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_effectiveDuration(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallableBond_effectiveDuration", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CallableBond_effectiveDuration__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CallableBond_effectiveDuration__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallableBond_effectiveDuration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CallableBond::effectiveDuration(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Real)\n"
    "    CallableBond::effectiveDuration(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CallableBond_effectiveConvexity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_effectiveConvexity" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_effectiveConvexity" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_effectiveConvexity" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveConvexity" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_effectiveConvexity" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveConvexity" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_effectiveConvexity" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_effectiveConvexity" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CallableBond_effectiveConvexity" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Real)(arg1)->effectiveConvexity(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_effectiveConvexity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CallableBond_effectiveConvexity" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CallableBond_effectiveConvexity" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CallableBond_effectiveConvexity" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveConvexity" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CallableBond_effectiveConvexity" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CallableBond_effectiveConvexity" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CallableBond_effectiveConvexity" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CallableBond_effectiveConvexity" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Real)(arg1)->effectiveConvexity(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CallableBond_effectiveConvexity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CallableBond_effectiveConvexity", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CallableBond_effectiveConvexity__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CallableBond_effectiveConvexity__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CallableBond_effectiveConvexity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CallableBond::effectiveConvexity(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Real)\n"
    "    CallableBond::effectiveConvexity(Real,Handle< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CallableBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CallableBond *arg1 = (CallableBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableBond > tempshared1 ;
  ext::shared_ptr< CallableBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallableBond" "', argument " "1"" of type '" "CallableBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableBond > * >(argp1);
      arg1 = const_cast< CallableBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CallableBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CallableBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CallableFixedRateBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Schedule *arg3 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  Real arg7 ;
  Date arg8 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg9 = 0 ;
  Period const &arg10_defvalue = Period() ;
  Period *arg10 = (Period *) &arg10_defvalue ;
  Calendar const &arg11_defvalue = Calendar() ;
  Calendar *arg11 = (Calendar *) &arg11_defvalue ;
  BusinessDayConvention arg12 = (BusinessDayConvention) Unadjusted ;
  bool arg13 = (bool) false ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"faceAmount",  (char *)"schedule",  (char *)"coupons",  (char *)"accrualDayCounter",  (char *)"paymentConvention",  (char *)"redemption",  (char *)"issueDate",  (char *)"putCallSchedule",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  CallableFixedRateBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO|OOOO:new_CallableFixedRateBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CallableFixedRateBond" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CallableFixedRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CallableFixedRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "3"" of type '" "Schedule const &""'"); 
  }
  arg3 = reinterpret_cast< Schedule * >(argp3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CallableFixedRateBond" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "4"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CallableFixedRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CallableFixedRateBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CallableFixedRateBond" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CallableFixedRateBond" "', argument " "8"" of type '" "Date""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "8"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res9 = swig::asptr(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CallableFixedRateBond" "', argument " "9"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "9"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg9 = ptr;
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CallableFixedRateBond" "', argument " "10"" of type '" "Period const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "10"" of type '" "Period const &""'"); 
    }
    arg10 = reinterpret_cast< Period * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CallableFixedRateBond" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableFixedRateBond" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    arg11 = reinterpret_cast< Calendar * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CallableFixedRateBond" "', argument " "12"" of type '" "BusinessDayConvention""'");
    } 
    arg12 = static_cast< BusinessDayConvention >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_bool(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_CallableFixedRateBond" "', argument " "13"" of type '" "bool""'");
    } 
    arg13 = static_cast< bool >(val13);
  }
  {
    try {
      result = (CallableFixedRateBond *)new CallableFixedRateBond(arg1,arg2,(Schedule const &)*arg3,(std::vector< Rate,std::allocator< Rate > > const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,arg8,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg9,(Period const &)*arg10,(Calendar const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CallableFixedRateBond > *smartresult = result ? new ext::shared_ptr<  CallableFixedRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CallableFixedRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CallableFixedRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CallableFixedRateBond *arg1 = (CallableFixedRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableFixedRateBond > tempshared1 ;
  ext::shared_ptr< CallableFixedRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableFixedRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallableFixedRateBond" "', argument " "1"" of type '" "CallableFixedRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableFixedRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableFixedRateBond > * >(argp1);
      arg1 = const_cast< CallableFixedRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableFixedRateBond > * >(argp1);
      arg1 = const_cast< CallableFixedRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CallableFixedRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CallableFixedRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CallableFixedRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CallableZeroCouponBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Calendar *arg3 = 0 ;
  Date *arg4 = 0 ;
  DayCounter *arg5 = 0 ;
  BusinessDayConvention arg6 = (BusinessDayConvention) Following ;
  Real arg7 = (Real) 100.0 ;
  Date const &arg8_defvalue = Date() ;
  Date *arg8 = (Date *) &arg8_defvalue ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &arg9_defvalue = std::vector< ext::shared_ptr< Callability > >() ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg9 = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *) &arg9_defvalue ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"faceAmount",  (char *)"calendar",  (char *)"maturityDate",  (char *)"dayCounter",  (char *)"paymentConvention",  (char *)"redemption",  (char *)"issueDate",  (char *)"putCallSchedule",  NULL 
  };
  CallableZeroCouponBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOOO:new_CallableZeroCouponBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CallableZeroCouponBond" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CallableZeroCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CallableZeroCouponBond" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableZeroCouponBond" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CallableZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CallableZeroCouponBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableZeroCouponBond" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CallableZeroCouponBond" "', argument " "6"" of type '" "BusinessDayConvention""'");
    } 
    arg6 = static_cast< BusinessDayConvention >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CallableZeroCouponBond" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CallableZeroCouponBond" "', argument " "8"" of type '" "Date const &""'"); 
    }
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableZeroCouponBond" "', argument " "8"" of type '" "Date const &""'"); 
    }
    arg8 = reinterpret_cast< Date * >(argp8);
  }
  if (obj8) {
    {
      std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CallableZeroCouponBond" "', argument " "9"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CallableZeroCouponBond" "', argument " "9"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  {
    try {
      result = (CallableZeroCouponBond *)new CallableZeroCouponBond(arg1,arg2,(Calendar const &)*arg3,(Date const &)*arg4,(DayCounter const &)*arg5,arg6,arg7,(Date const &)*arg8,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CallableZeroCouponBond > *smartresult = result ? new ext::shared_ptr<  CallableZeroCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CallableZeroCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CallableZeroCouponBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CallableZeroCouponBond *arg1 = (CallableZeroCouponBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CallableZeroCouponBond > tempshared1 ;
  ext::shared_ptr< CallableZeroCouponBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CallableZeroCouponBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CallableZeroCouponBond" "', argument " "1"" of type '" "CallableZeroCouponBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CallableZeroCouponBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CallableZeroCouponBond > * >(argp1);
      arg1 = const_cast< CallableZeroCouponBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CallableZeroCouponBond > * >(argp1);
      arg1 = const_cast< CallableZeroCouponBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CallableZeroCouponBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CallableZeroCouponBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CallableZeroCouponBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TreeCallableFixedRateBondEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCallableFixedRateBondEngine > *smartresult = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCallableFixedRateBondEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCallableFixedRateBondEngine > *smartresult = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCallableFixedRateBondEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCallableFixedRateBondEngine > *smartresult = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCallableFixedRateBondEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ShortRateModel > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ShortRateModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  TreeCallableFixedRateBondEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "1"" of type '" "ext::shared_ptr< ShortRateModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ShortRateModel > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TreeCallableFixedRateBondEngine" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  {
    try {
      result = (TreeCallableFixedRateBondEngine *)new TreeCallableFixedRateBondEngine((ext::shared_ptr< ShortRateModel > const &)*arg1,(TimeGrid const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TreeCallableFixedRateBondEngine > *smartresult = result ? new ext::shared_ptr<  TreeCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TreeCallableFixedRateBondEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TreeCallableFixedRateBondEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TreeCallableFixedRateBondEngine__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TreeCallableFixedRateBondEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeCallableFixedRateBondEngine__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ShortRateModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TreeCallableFixedRateBondEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TreeCallableFixedRateBondEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TreeCallableFixedRateBondEngine::TreeCallableFixedRateBondEngine(ext::shared_ptr< ShortRateModel > const &,Size,Handle< YieldTermStructure > const &)\n"
    "    TreeCallableFixedRateBondEngine::TreeCallableFixedRateBondEngine(ext::shared_ptr< ShortRateModel > const &,Size)\n"
    "    TreeCallableFixedRateBondEngine::TreeCallableFixedRateBondEngine(ext::shared_ptr< ShortRateModel > const &,TimeGrid const &,Handle< YieldTermStructure > const &)\n"
    "    TreeCallableFixedRateBondEngine::TreeCallableFixedRateBondEngine(ext::shared_ptr< ShortRateModel > const &,TimeGrid const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TreeCallableFixedRateBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TreeCallableFixedRateBondEngine *arg1 = (TreeCallableFixedRateBondEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TreeCallableFixedRateBondEngine > tempshared1 ;
  ext::shared_ptr< TreeCallableFixedRateBondEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TreeCallableFixedRateBondEngine" "', argument " "1"" of type '" "TreeCallableFixedRateBondEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TreeCallableFixedRateBondEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TreeCallableFixedRateBondEngine > * >(argp1);
      arg1 = const_cast< TreeCallableFixedRateBondEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TreeCallableFixedRateBondEngine > * >(argp1);
      arg1 = const_cast< TreeCallableFixedRateBondEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TreeCallableFixedRateBondEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TreeCallableFixedRateBondEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackCallableFixedRateBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  BlackCallableFixedRateBondEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackCallableFixedRateBondEngine", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCallableFixedRateBondEngine" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCallableFixedRateBondEngine" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCallableFixedRateBondEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCallableFixedRateBondEngine" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (BlackCallableFixedRateBondEngine *)new BlackCallableFixedRateBondEngine((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCallableFixedRateBondEngine > *smartresult = result ? new ext::shared_ptr<  BlackCallableFixedRateBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackCallableFixedRateBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCallableFixedRateBondEngine *arg1 = (BlackCallableFixedRateBondEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCallableFixedRateBondEngine > tempshared1 ;
  ext::shared_ptr< BlackCallableFixedRateBondEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackCallableFixedRateBondEngine" "', argument " "1"" of type '" "BlackCallableFixedRateBondEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCallableFixedRateBondEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCallableFixedRateBondEngine > * >(argp1);
      arg1 = const_cast< BlackCallableFixedRateBondEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCallableFixedRateBondEngine > * >(argp1);
      arg1 = const_cast< BlackCallableFixedRateBondEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackCallableFixedRateBondEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackCallableFixedRateBondEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CPIBond(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Real arg2 ;
  bool arg3 ;
  Real arg4 ;
  Period *arg5 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > *arg6 = 0 ;
  CPI::InterpolationType arg7 ;
  Schedule *arg8 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  DayCounter *arg10 = 0 ;
  BusinessDayConvention arg11 = (BusinessDayConvention) ModifiedFollowing ;
  Date const &arg12_defvalue = Date() ;
  Date *arg12 = (Date *) &arg12_defvalue ;
  Calendar const &arg13_defvalue = Calendar() ;
  Calendar *arg13 = (Calendar *) &arg13_defvalue ;
  Period const &arg14_defvalue = Period() ;
  Period *arg14 = (Period *) &arg14_defvalue ;
  Calendar const &arg15_defvalue = Calendar() ;
  Calendar *arg15 = (Calendar *) &arg15_defvalue ;
  BusinessDayConvention arg16 = (BusinessDayConvention) Unadjusted ;
  bool arg17 = (bool) false ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< ZeroInflationIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"faceAmount",  (char *)"growthOnly",  (char *)"baseCPI",  (char *)"observationLag",  (char *)"cpiIndex",  (char *)"observationInterpolation",  (char *)"schedule",  (char *)"coupons",  (char *)"accrualDayCounter",  (char *)"paymentConvention",  (char *)"issueDate",  (char *)"paymentCalendar",  (char *)"exCouponPeriod",  (char *)"exCouponCalendar",  (char *)"exCouponConvention",  (char *)"exCouponEndOfMonth",  NULL 
  };
  CPIBond *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOO|OOOOOOO:new_CPIBond", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CPIBond" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CPIBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CPIBond" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CPIBond" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CPIBond" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(obj5, &argp6, SWIGTYPE_p_ext__shared_ptrT_ZeroInflationIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CPIBond" "', argument " "6"" of type '" "ext::shared_ptr< ZeroInflationIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< ZeroInflationIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CPIBond" "', argument " "7"" of type '" "CPI::InterpolationType""'");
  } 
  arg7 = static_cast< CPI::InterpolationType >(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CPIBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(obj8, &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CPIBond" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CPIBond" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "10"" of type '" "DayCounter const &""'"); 
  }
  arg10 = reinterpret_cast< DayCounter * >(argp10);
  if (obj10) {
    ecode11 = SWIG_AsVal_int(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CPIBond" "', argument " "11"" of type '" "BusinessDayConvention""'");
    } 
    arg11 = static_cast< BusinessDayConvention >(val11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CPIBond" "', argument " "12"" of type '" "Date const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "12"" of type '" "Date const &""'"); 
    }
    arg12 = reinterpret_cast< Date * >(argp12);
  }
  if (obj12) {
    res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CPIBond" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "13"" of type '" "Calendar const &""'"); 
    }
    arg13 = reinterpret_cast< Calendar * >(argp13);
  }
  if (obj13) {
    res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_CPIBond" "', argument " "14"" of type '" "Period const &""'"); 
    }
    if (!argp14) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "14"" of type '" "Period const &""'"); 
    }
    arg14 = reinterpret_cast< Period * >(argp14);
  }
  if (obj14) {
    res15 = SWIG_ConvertPtr(obj14, &argp15, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res15)) {
      SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CPIBond" "', argument " "15"" of type '" "Calendar const &""'"); 
    }
    if (!argp15) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPIBond" "', argument " "15"" of type '" "Calendar const &""'"); 
    }
    arg15 = reinterpret_cast< Calendar * >(argp15);
  }
  if (obj15) {
    ecode16 = SWIG_AsVal_int(obj15, &val16);
    if (!SWIG_IsOK(ecode16)) {
      SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_CPIBond" "', argument " "16"" of type '" "BusinessDayConvention""'");
    } 
    arg16 = static_cast< BusinessDayConvention >(val16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_bool(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_CPIBond" "', argument " "17"" of type '" "bool""'");
    } 
    arg17 = static_cast< bool >(val17);
  }
  {
    try {
      result = (CPIBond *)new CPIBond(arg1,arg2,arg3,arg4,(Period const &)*arg5,(ext::shared_ptr< ZeroInflationIndex > const &)*arg6,arg7,(Schedule const &)*arg8,(std::vector< Rate,std::allocator< Rate > > const &)*arg9,(DayCounter const &)*arg10,arg11,(Date const &)*arg12,(Calendar const &)*arg13,(Period const &)*arg14,(Calendar const &)*arg15,arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CPIBond > *smartresult = result ? new ext::shared_ptr<  CPIBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CPIBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CPIBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CPIBond *arg1 = (CPIBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CPIBond > tempshared1 ;
  ext::shared_ptr< CPIBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CPIBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPIBond" "', argument " "1"" of type '" "CPIBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CPIBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CPIBond > * >(argp1);
      arg1 = const_cast< CPIBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CPIBond > * >(argp1);
      arg1 = const_cast< CPIBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CPIBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CPIBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CPIBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BondFunctions_startDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_startDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_startDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = BondFunctions::startDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_maturityDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_maturityDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = BondFunctions::maturityDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_isTradable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_isTradable" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_isTradable" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_isTradable" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_isTradable" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)BondFunctions::isTradable((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_isTradable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_isTradable" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_isTradable" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (bool)BondFunctions::isTradable((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_isTradable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_isTradable", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_isTradable__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_isTradable__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_isTradable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::isTradable(Bond const &,Date)\n"
    "    BondFunctions::isTradable(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_previousCashFlowDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCashFlowDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_previousCashFlowDate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCashFlowDate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = BondFunctions::previousCashFlowDate((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_previousCashFlowDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCashFlowDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = BondFunctions::previousCashFlowDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_previousCashFlowDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_previousCashFlowDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_previousCashFlowDate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_previousCashFlowDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::previousCashFlowDate(Bond const &,Date)\n"
    "    BondFunctions::previousCashFlowDate(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_nextCashFlowDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCashFlowDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_nextCashFlowDate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCashFlowDate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = BondFunctions::nextCashFlowDate((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_nextCashFlowDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCashFlowDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = BondFunctions::nextCashFlowDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_nextCashFlowDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_nextCashFlowDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_nextCashFlowDate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_nextCashFlowDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::nextCashFlowDate(Bond const &,Date)\n"
    "    BondFunctions::nextCashFlowDate(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowAmount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_previousCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_previousCashFlowAmount" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCashFlowAmount" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::previousCashFlowAmount((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowAmount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_previousCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Real)BondFunctions::previousCashFlowAmount((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCashFlowAmount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_previousCashFlowAmount", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_previousCashFlowAmount__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_previousCashFlowAmount__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_previousCashFlowAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::previousCashFlowAmount(Bond const &,Date)\n"
    "    BondFunctions::previousCashFlowAmount(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowAmount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_nextCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_nextCashFlowAmount" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCashFlowAmount" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::nextCashFlowAmount((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowAmount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_nextCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCashFlowAmount" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Real)BondFunctions::nextCashFlowAmount((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCashFlowAmount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_nextCashFlowAmount", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_nextCashFlowAmount__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_nextCashFlowAmount__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_nextCashFlowAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::nextCashFlowAmount(Bond const &,Date)\n"
    "    BondFunctions::nextCashFlowAmount(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCouponRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_previousCouponRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCouponRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_previousCouponRate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCouponRate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions::previousCouponRate((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCouponRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Rate result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_previousCouponRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_previousCouponRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Rate)BondFunctions::previousCouponRate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_previousCouponRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_previousCouponRate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_previousCouponRate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_previousCouponRate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_previousCouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::previousCouponRate(Bond const &,Date)\n"
    "    BondFunctions::previousCouponRate(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCouponRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_nextCouponRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCouponRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_nextCouponRate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCouponRate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions::nextCouponRate((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCouponRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Rate result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_nextCouponRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_nextCouponRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Rate)BondFunctions::nextCouponRate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_nextCouponRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_nextCouponRate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_nextCouponRate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_nextCouponRate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_nextCouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::nextCouponRate(Bond const &,Date)\n"
    "    BondFunctions::nextCouponRate(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualStartDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualStartDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualStartDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accrualStartDate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualStartDate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = BondFunctions::accrualStartDate((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualStartDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualStartDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualStartDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = BondFunctions::accrualStartDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualStartDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accrualStartDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accrualStartDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accrualStartDate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accrualStartDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accrualStartDate(Bond const &,Date)\n"
    "    BondFunctions::accrualStartDate(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualEndDate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Date result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualEndDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualEndDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accrualEndDate" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualEndDate" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = BondFunctions::accrualEndDate((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualEndDate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Date result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualEndDate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualEndDate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = BondFunctions::accrualEndDate((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualEndDate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accrualEndDate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accrualEndDate__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accrualEndDate__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accrualEndDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accrualEndDate(Bond const &,Date)\n"
    "    BondFunctions::accrualEndDate(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualPeriod__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Time result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualPeriod" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualPeriod" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accrualPeriod" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualPeriod" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Time)BondFunctions::accrualPeriod((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualPeriod__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Time result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualPeriod" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualPeriod" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Time)BondFunctions::accrualPeriod((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualPeriod(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accrualPeriod", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accrualPeriod__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accrualPeriod__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accrualPeriod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accrualPeriod(Bond const &,Date)\n"
    "    BondFunctions::accrualPeriod(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualDays__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  BigInteger result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualDays" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualDays" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accrualDays" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualDays" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (BigInteger)BondFunctions::accrualDays((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualDays__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  BigInteger result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accrualDays" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accrualDays" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (BigInteger)BondFunctions::accrualDays((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accrualDays(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accrualDays", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accrualDays__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accrualDays__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accrualDays'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accrualDays(Bond const &,Date)\n"
    "    BondFunctions::accrualDays(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedPeriod__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Time result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accruedPeriod" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedPeriod" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accruedPeriod" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedPeriod" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Time)BondFunctions::accruedPeriod((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedPeriod__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Time result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accruedPeriod" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedPeriod" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Time)BondFunctions::accruedPeriod((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedPeriod(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accruedPeriod", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accruedPeriod__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accruedPeriod__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accruedPeriod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accruedPeriod(Bond const &,Date)\n"
    "    BondFunctions::accruedPeriod(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedDays__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  BigInteger result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accruedDays" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedDays" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accruedDays" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedDays" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (BigInteger)BondFunctions::accruedDays((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedDays__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  BigInteger result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accruedDays" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedDays" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (BigInteger)BondFunctions::accruedDays((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedDays(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accruedDays", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accruedDays__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accruedDays__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accruedDays'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accruedDays(Bond const &,Date)\n"
    "    BondFunctions::accruedDays(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedAmount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Date arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accruedAmount" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedAmount" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_accruedAmount" "', argument " "2"" of type '" "Date""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedAmount" "', argument " "2"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::accruedAmount((Bond const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedAmount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  Real result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_accruedAmount" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_accruedAmount" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    try {
      result = (Real)BondFunctions::accruedAmount((Bond const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_accruedAmount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_accruedAmount", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BondFunctions_accruedAmount__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_accruedAmount__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_accruedAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::accruedAmount(Bond const &,Date)\n"
    "    BondFunctions::accruedAmount(Bond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,(YieldTermStructure const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,(YieldTermStructure const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_atmRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_atmRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_atmRate" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_atmRate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Rate)BondFunctions::atmRate((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_atmRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  Rate result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_atmRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_atmRate" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions::atmRate((Bond const &)*arg1,(YieldTermStructure const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_atmRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  YieldTermStructure *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  Rate result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_atmRate" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    try {
      result = (Rate)BondFunctions::atmRate((Bond const &)*arg1,(YieldTermStructure const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_atmRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_atmRate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_atmRate__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_atmRate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BondFunctions_atmRate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_atmRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::atmRate(Bond const &,YieldTermStructure const &,Date,Real)\n"
    "    BondFunctions::atmRate(Bond const &,YieldTermStructure const &,Date)\n"
    "    BondFunctions::atmRate(Bond const &,YieldTermStructure const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_cleanPrice" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_cleanPrice" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_cleanPrice" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_cleanPrice" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_cleanPrice" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_cleanPrice" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_cleanPrice" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)BondFunctions::cleanPrice((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_cleanPrice(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_cleanPrice", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_cleanPrice__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_cleanPrice__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_cleanPrice__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_cleanPrice__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_cleanPrice__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_BondFunctions_cleanPrice__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_cleanPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::cleanPrice(Bond const &,YieldTermStructure const &,Date)\n"
    "    BondFunctions::cleanPrice(Bond const &,YieldTermStructure const &)\n"
    "    BondFunctions::cleanPrice(Bond const &,InterestRate const &,Date)\n"
    "    BondFunctions::cleanPrice(Bond const &,InterestRate const &)\n"
    "    BondFunctions::cleanPrice(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::cleanPrice(Bond const &,Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bps" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bps" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_bps" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bps" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bps" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bps" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bps" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)BondFunctions::bps((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bps(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_bps", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_bps__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_bps__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_bps__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_bps__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_bps__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_BondFunctions_bps__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_bps'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::bps(Bond const &,YieldTermStructure const &,Date)\n"
    "    BondFunctions::bps(Bond const &,YieldTermStructure const &)\n"
    "    BondFunctions::bps(Bond const &,InterestRate const &,Date)\n"
    "    BondFunctions::bps(Bond const &,InterestRate const &)\n"
    "    BondFunctions::bps(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::bps(Bond const &,Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bondYield__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Size arg8 ;
  Rate arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BondFunctions_bondYield" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_bondYield" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_bondYield" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions::yield((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6),arg7,SWIG_STD_MOVE(arg8),arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bondYield__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  Size arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BondFunctions_bondYield" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_bondYield" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  {
    try {
      result = (Rate)BondFunctions::yield((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6),arg7,SWIG_STD_MOVE(arg8));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bondYield__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BondFunctions_bondYield" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (Rate)BondFunctions::yield((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bondYield__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions::yield((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bondYield__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_bondYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_bondYield" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_bondYield" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_bondYield" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Rate)BondFunctions::yield((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_bondYield(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_bondYield", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_bondYield__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_BondFunctions_bondYield__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_BondFunctions_bondYield__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_bondYield__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_bondYield__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_bondYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yield(Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Size,Rate)\n"
    "    BondFunctions::yield(Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Size)\n"
    "    BondFunctions::yield(Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yield(Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::yield(Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  Date arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Time result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "Duration::Type""'");
  } 
  arg3 = static_cast< Duration::Type >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_duration" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (Time)BondFunctions::duration((Bond const &)*arg1,(InterestRate const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Duration::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Time result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "Duration::Type""'");
  } 
  arg3 = static_cast< Duration::Type >(val3);
  {
    try {
      result = (Time)BondFunctions::duration((Bond const &)*arg1,(InterestRate const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Time result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    try {
      result = (Time)BondFunctions::duration((Bond const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  Date arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double 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 ;
  int res7 = 0 ;
  Time result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_duration" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_duration" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_duration" "', argument " "6"" of type '" "Duration::Type""'");
  } 
  arg6 = static_cast< Duration::Type >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_duration" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Time)BondFunctions::duration((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Duration::Type arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double 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 ;
  Time result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_duration" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_duration" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_duration" "', argument " "6"" of type '" "Duration::Type""'");
  } 
  arg6 = static_cast< Duration::Type >(val6);
  {
    try {
      result = (Time)BondFunctions::duration((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Time result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_duration" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_duration" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_duration" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_duration" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Time)BondFunctions::duration((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_duration(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_duration", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_duration__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BondFunctions_duration__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BondFunctions_duration__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_duration__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_duration__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_duration__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_duration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::duration(Bond const &,InterestRate const &,Duration::Type,Date)\n"
    "    BondFunctions::duration(Bond const &,InterestRate const &,Duration::Type)\n"
    "    BondFunctions::duration(Bond const &,InterestRate const &)\n"
    "    BondFunctions::duration(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Duration::Type,Date)\n"
    "    BondFunctions::duration(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Duration::Type)\n"
    "    BondFunctions::duration(Bond const &,Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_convexity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_convexity" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::convexity((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_convexity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    try {
      result = (Real)BondFunctions::convexity((Bond const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_convexity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_convexity" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_convexity" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_convexity" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_convexity" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::convexity((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_convexity__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_convexity" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_convexity" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_convexity" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_convexity" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)BondFunctions::convexity((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_convexity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_convexity", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_convexity__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_convexity__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_convexity__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_BondFunctions_convexity__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_convexity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::convexity(Bond const &,InterestRate const &,Date)\n"
    "    BondFunctions::convexity(Bond const &,InterestRate const &)\n"
    "    BondFunctions::convexity(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::convexity(Bond const &,Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_basisPointValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_basisPointValue" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::basisPointValue((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_basisPointValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    try {
      result = (Real)BondFunctions::basisPointValue((Bond const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_basisPointValue__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_basisPointValue" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_basisPointValue" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_basisPointValue" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_basisPointValue" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::basisPointValue((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_basisPointValue__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_basisPointValue" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_basisPointValue" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_basisPointValue" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_basisPointValue" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)BondFunctions::basisPointValue((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_basisPointValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_basisPointValue", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_basisPointValue__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_basisPointValue__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_basisPointValue__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_BondFunctions_basisPointValue__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_basisPointValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::basisPointValue(Bond const &,InterestRate const &,Date)\n"
    "    BondFunctions::basisPointValue(Bond const &,InterestRate const &)\n"
    "    BondFunctions::basisPointValue(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::basisPointValue(Bond const &,Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldValueBasisPoint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  Date arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::yieldValueBasisPoint((Bond const &)*arg1,(InterestRate const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldValueBasisPoint__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  InterestRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InterestRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "2"" of type '" "InterestRate const &""'"); 
  }
  arg2 = reinterpret_cast< InterestRate * >(argp2);
  {
    try {
      result = (Real)BondFunctions::yieldValueBasisPoint((Bond const &)*arg1,(InterestRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldValueBasisPoint__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (Real)BondFunctions::yieldValueBasisPoint((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5,SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldValueBasisPoint__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Rate arg2 ;
  DayCounter *arg3 = 0 ;
  Compounding arg4 ;
  Frequency arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "4"" of type '" "Compounding""'");
  } 
  arg4 = static_cast< Compounding >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldValueBasisPoint" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  {
    try {
      result = (Real)BondFunctions::yieldValueBasisPoint((Bond const &)*arg1,arg2,(DayCounter const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldValueBasisPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldValueBasisPoint", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BondFunctions_yieldValueBasisPoint__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InterestRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondFunctions_yieldValueBasisPoint__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BondFunctions_yieldValueBasisPoint__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_BondFunctions_yieldValueBasisPoint__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldValueBasisPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldValueBasisPoint(Bond const &,InterestRate const &,Date)\n"
    "    BondFunctions::yieldValueBasisPoint(Bond const &,InterestRate const &)\n"
    "    BondFunctions::yieldValueBasisPoint(Bond const &,Rate,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::yieldValueBasisPoint(Bond const &,Rate,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_zSpread__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Size arg9 ;
  Rate arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Spread result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_zSpread" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_zSpread" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "BondFunctions_zSpread" "', argument " "10"" of type '" "Rate""'");
  } 
  arg10 = static_cast< Rate >(val10);
  {
    try {
      result = (Spread)BondFunctions::zSpread((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,SWIG_STD_MOVE(arg9),arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_zSpread__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Size arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  Spread result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_zSpread" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_size_t(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_zSpread" "', argument " "9"" of type '" "Size""'");
  } 
  arg9 = static_cast< Size >(val9);
  {
    try {
      result = (Spread)BondFunctions::zSpread((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,SWIG_STD_MOVE(arg9));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_zSpread__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Spread result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_zSpread" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Spread)BondFunctions::zSpread((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_zSpread__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Spread result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Spread)BondFunctions::zSpread((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_zSpread__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bond *arg1 = 0 ;
  Real arg2 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond const > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Spread result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "1"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1);
      arg1 = const_cast< Bond * >(tempshared1.get());
    } else {
      arg1 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp1)->get());
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondFunctions_zSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondFunctions_zSpread" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_zSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_zSpread" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_zSpread" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Spread)BondFunctions::zSpread((Bond const &)*arg1,arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_zSpread(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_zSpread", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_zSpread__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_zSpread__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_zSpread__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_zSpread__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_BondFunctions_zSpread__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_zSpread'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::zSpread(Bond const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date,Real,Size,Rate)\n"
    "    BondFunctions::zSpread(Bond const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date,Real,Size)\n"
    "    BondFunctions::zSpread(Bond const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::zSpread(Bond const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::zSpread(Bond const &,Real,ext::shared_ptr< YieldTermStructure > const &,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBrent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Brent arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Brent,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'");
    } else {
      Brent * temp = reinterpret_cast< Brent * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBrent" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBrent" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBrent" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldBrent" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldBrent" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldBrent" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBrent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Brent arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Brent,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'");
    } else {
      Brent * temp = reinterpret_cast< Brent * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBrent" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBrent" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBrent" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldBrent" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldBrent" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBrent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Brent arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Brent,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'");
    } else {
      Brent * temp = reinterpret_cast< Brent * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBrent" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBrent" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBrent" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldBrent" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBrent__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Brent arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Brent,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "1"" of type '" "Brent""'");
    } else {
      Brent * temp = reinterpret_cast< Brent * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBrent" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBrent" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBrent" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBrent" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldBrent__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBrent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldBrent", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Brent, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldBrent__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Brent, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldBrent__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Brent, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldBrent__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Brent, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldBrent__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldBrent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldBrent(Brent,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldBrent(Brent,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldBrent(Brent,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldBrent__SWIG_0(Brent,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBisection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bisection arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Bisection,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'");
    } else {
      Bisection * temp = reinterpret_cast< Bisection * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBisection" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBisection" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBisection" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldBisection" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldBisection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldBisection" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBisection__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bisection arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Bisection,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'");
    } else {
      Bisection * temp = reinterpret_cast< Bisection * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBisection" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBisection" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBisection" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldBisection" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldBisection" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBisection__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bisection arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Bisection,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'");
    } else {
      Bisection * temp = reinterpret_cast< Bisection * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBisection" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBisection" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBisection" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldBisection" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBisection__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Bisection arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Bisection,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "1"" of type '" "Bisection""'");
    } else {
      Bisection * temp = reinterpret_cast< Bisection * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldBisection" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldBisection" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldBisection" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldBisection" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldBisection__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldBisection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldBisection", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Bisection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldBisection__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Bisection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldBisection__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Bisection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldBisection__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Bisection, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldBisection__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldBisection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldBisection(Bisection,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldBisection(Bisection,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldBisection(Bisection,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldBisection__SWIG_0(Bisection,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldFalsePosition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FalsePosition arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FalsePosition,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'");
    } else {
      FalsePosition * temp = reinterpret_cast< FalsePosition * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldFalsePosition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FalsePosition arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FalsePosition,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'");
    } else {
      FalsePosition * temp = reinterpret_cast< FalsePosition * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldFalsePosition__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FalsePosition arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FalsePosition,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'");
    } else {
      FalsePosition * temp = reinterpret_cast< FalsePosition * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldFalsePosition__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FalsePosition arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FalsePosition,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "1"" of type '" "FalsePosition""'");
    } else {
      FalsePosition * temp = reinterpret_cast< FalsePosition * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldFalsePosition" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldFalsePosition" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldFalsePosition__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldFalsePosition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldFalsePosition", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FalsePosition, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldFalsePosition__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FalsePosition, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldFalsePosition__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FalsePosition, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldFalsePosition__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FalsePosition, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldFalsePosition__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldFalsePosition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldFalsePosition(FalsePosition,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldFalsePosition(FalsePosition,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldFalsePosition(FalsePosition,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldFalsePosition__SWIG_0(FalsePosition,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldRidder__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Ridder arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Ridder,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'");
    } else {
      Ridder * temp = reinterpret_cast< Ridder * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldRidder" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldRidder" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldRidder" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldRidder" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldRidder" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldRidder" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldRidder__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Ridder arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Ridder,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'");
    } else {
      Ridder * temp = reinterpret_cast< Ridder * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldRidder" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldRidder" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldRidder" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldRidder" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldRidder" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldRidder__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Ridder arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Ridder,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'");
    } else {
      Ridder * temp = reinterpret_cast< Ridder * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldRidder" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldRidder" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldRidder" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldRidder" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldRidder__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Ridder arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Ridder,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "1"" of type '" "Ridder""'");
    } else {
      Ridder * temp = reinterpret_cast< Ridder * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldRidder" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldRidder" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldRidder" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldRidder" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldRidder__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldRidder(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldRidder", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Ridder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldRidder__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Ridder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldRidder__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Ridder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldRidder__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Ridder, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldRidder__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldRidder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldRidder(Ridder,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldRidder(Ridder,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldRidder(Ridder,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldRidder__SWIG_0(Ridder,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldSecant__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Secant arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Secant,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'");
    } else {
      Secant * temp = reinterpret_cast< Secant * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldSecant" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldSecant" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldSecant" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldSecant" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldSecant" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldSecant" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldSecant__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Secant arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Secant,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'");
    } else {
      Secant * temp = reinterpret_cast< Secant * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldSecant" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldSecant" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldSecant" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldSecant" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldSecant" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldSecant__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Secant arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Secant,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'");
    } else {
      Secant * temp = reinterpret_cast< Secant * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldSecant" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldSecant" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldSecant" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldSecant" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldSecant__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Secant arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Secant,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "1"" of type '" "Secant""'");
    } else {
      Secant * temp = reinterpret_cast< Secant * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldSecant" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldSecant" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldSecant" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldSecant" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldSecant__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldSecant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldSecant", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Secant, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldSecant__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Secant, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldSecant__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Secant, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldSecant__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Secant, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldSecant__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldSecant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldSecant(Secant,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldSecant(Secant,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldSecant(Secant,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldSecant__SWIG_0(Secant,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Newton arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Newton,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'");
    } else {
      Newton * temp = reinterpret_cast< Newton * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewton" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewton" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewton" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldNewton" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldNewton" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldNewton" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldNewton__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Newton arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Newton,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'");
    } else {
      Newton * temp = reinterpret_cast< Newton * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewton" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewton" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewton" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldNewton" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldNewton" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldNewton__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewton__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Newton arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Newton,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'");
    } else {
      Newton * temp = reinterpret_cast< Newton * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewton" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewton" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewton" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldNewton" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldNewton__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewton__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Newton arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Newton,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "1"" of type '" "Newton""'");
    } else {
      Newton * temp = reinterpret_cast< Newton * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewton" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewton" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewton" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewton" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldNewton__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldNewton", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Newton, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldNewton__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Newton, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldNewton__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Newton, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldNewton__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Newton, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldNewton__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldNewton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldNewton(Newton,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldNewton(Newton,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldNewton(Newton,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldNewton__SWIG_0(Newton,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewtonSafe__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewtonSafe arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  Rate arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Rate result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_NewtonSafe,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'");
    } else {
      NewtonSafe * temp = reinterpret_cast< NewtonSafe * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "9"" of type '" "Rate""'");
  } 
  arg9 = static_cast< Rate >(val9);
  {
    try {
      result = (Rate)BondFunctions_yieldNewtonSafe__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewtonSafe__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewtonSafe arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Rate result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_NewtonSafe,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'");
    } else {
      NewtonSafe * temp = reinterpret_cast< NewtonSafe * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Rate)BondFunctions_yieldNewtonSafe__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7),arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewtonSafe__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewtonSafe arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  Date arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_NewtonSafe,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'");
    } else {
      NewtonSafe * temp = reinterpret_cast< NewtonSafe * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (Rate)BondFunctions_yieldNewtonSafe__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6,SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewtonSafe__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  NewtonSafe arg1 ;
  Bond *arg2 = 0 ;
  Real arg3 ;
  DayCounter *arg4 = 0 ;
  Compounding arg5 ;
  Frequency arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond const > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_NewtonSafe,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "1"" of type '" "NewtonSafe""'");
    } else {
      NewtonSafe * temp = reinterpret_cast< NewtonSafe * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "2"" of type '" "Bond const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2);
      arg2 = const_cast< Bond * >(tempshared2.get());
    } else {
      arg2 = const_cast< Bond * >(reinterpret_cast< ext::shared_ptr< const Bond > * >(argp2)->get());
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BondFunctions_yieldNewtonSafe" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    try {
      result = (Rate)BondFunctions_yieldNewtonSafe__SWIG_0(SWIG_STD_MOVE(arg1),(Bond const &)*arg2,arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondFunctions_yieldNewtonSafe(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondFunctions_yieldNewtonSafe", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_NewtonSafe, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BondFunctions_yieldNewtonSafe__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_NewtonSafe, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_BondFunctions_yieldNewtonSafe__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_NewtonSafe, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_BondFunctions_yieldNewtonSafe__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_NewtonSafe, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_BondFunctions_yieldNewtonSafe__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondFunctions_yieldNewtonSafe'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondFunctions::yieldNewtonSafe(NewtonSafe,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real,Rate)\n"
    "    BondFunctions::yieldNewtonSafe(NewtonSafe,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date,Real)\n"
    "    BondFunctions::yieldNewtonSafe(NewtonSafe,Bond const &,Real,DayCounter const &,Compounding,Frequency,Date)\n"
    "    BondFunctions::BondFunctions_yieldNewtonSafe__SWIG_0(NewtonSafe,Bond const &,Real,DayCounter const &,Compounding,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BondFunctions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondFunctions *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BondFunctions", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (BondFunctions *)new BondFunctions();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BondFunctions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BondFunctions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondFunctions *arg1 = (BondFunctions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BondFunctions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BondFunctions" "', argument " "1"" of type '" "BondFunctions *""'"); 
  }
  arg1 = reinterpret_cast< BondFunctions * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BondFunctions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BondFunctions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BondFunctions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_setPricingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  ext::shared_ptr< PricingEngine > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< PricingEngine > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelper_setPricingEngine", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_setPricingEngine" "', argument " "1"" of type '" "BlackCalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_PricingEngine_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackCalibrationHelper_setPricingEngine" "', argument " "2"" of type '" "ext::shared_ptr< PricingEngine > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< PricingEngine > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->setPricingEngine((ext::shared_ptr< PricingEngine > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_marketValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_marketValue" "', argument " "1"" of type '" "BlackCalibrationHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BlackCalibrationHelper const *)arg1)->marketValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_modelValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_modelValue" "', argument " "1"" of type '" "BlackCalibrationHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((BlackCalibrationHelper const *)arg1)->modelValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_impliedVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Size arg4 ;
  Volatility arg5 ;
  Volatility arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  Volatility result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelper_impliedVolatility", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_impliedVolatility" "', argument " "1"" of type '" "BlackCalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelper_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalibrationHelper_impliedVolatility" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlackCalibrationHelper_impliedVolatility" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlackCalibrationHelper_impliedVolatility" "', argument " "5"" of type '" "Volatility""'");
  } 
  arg5 = static_cast< Volatility >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BlackCalibrationHelper_impliedVolatility" "', argument " "6"" of type '" "Volatility""'");
  } 
  arg6 = static_cast< Volatility >(val6);
  {
    try {
      result = (Volatility)(arg1)->impliedVolatility(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_blackPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  Volatility arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelper_blackPrice", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_blackPrice" "', argument " "1"" of type '" "BlackCalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelper_blackPrice" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  {
    try {
      result = (Real)(arg1)->blackPrice(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_volatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_volatility" "', argument " "1"" of type '" "BlackCalibrationHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BlackCalibrationHelper const *)arg1)->volatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_volatilityType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper const > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  VolatilityType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_volatilityType" "', argument " "1"" of type '" "BlackCalibrationHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (VolatilityType)((BlackCalibrationHelper const *)arg1)->volatilityType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelper_calibrationError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelper_calibrationError" "', argument " "1"" of type '" "BlackCalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->calibrationError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackCalibrationHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCalibrationHelper *arg1 = (BlackCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempshared1 ;
  ext::shared_ptr< BlackCalibrationHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackCalibrationHelper" "', argument " "1"" of type '" "BlackCalibrationHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCalibrationHelper > * >(argp1);
      arg1 = const_cast< BlackCalibrationHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackCalibrationHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_as_black_helper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CalibrationHelper > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CalibrationHelper > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< BlackCalibrationHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_black_helper" "', argument " "1"" of type '" "ext::shared_ptr< CalibrationHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CalibrationHelper > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CalibrationHelper > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_black_helper((ext::shared_ptr< CalibrationHelper > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCalibrationHelper > *smartresult = result ? new ext::shared_ptr<  BlackCalibrationHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_as_swaption_helper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BlackCalibrationHelper > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCalibrationHelper > tempshared1 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwaptionHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_swaption_helper" "', argument " "1"" of type '" "ext::shared_ptr< BlackCalibrationHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BlackCalibrationHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BlackCalibrationHelper > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BlackCalibrationHelper > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = as_swaption_helper((ext::shared_ptr< BlackCalibrationHelper > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ext::shared_ptr< SwaptionHelper >(result)), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwaptionHelper" "', argument " "12"" of type '" "VolatilityType""'");
  } 
  arg12 = static_cast< VolatilityType >(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SwaptionHelper" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwaptionHelper" "', argument " "12"" of type '" "VolatilityType""'");
  } 
  arg12 = static_cast< VolatilityType >(val12);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Period const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwaptionHelper" "', argument " "12"" of type '" "VolatilityType""'");
  } 
  arg12 = static_cast< VolatilityType >(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SwaptionHelper" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwaptionHelper" "', argument " "12"" of type '" "VolatilityType""'");
  } 
  arg12 = static_cast< VolatilityType >(val12);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  Real arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwaptionHelper" "', argument " "12"" of type '" "VolatilityType""'");
  } 
  arg12 = static_cast< VolatilityType >(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SwaptionHelper" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  VolatilityType arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwaptionHelper" "', argument " "12"" of type '" "VolatilityType""'");
  } 
  arg12 = static_cast< VolatilityType >(val12);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwaptionHelper" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SwaptionHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  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 val9 ;
  int ecode9 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SwaptionHelper" "', argument " "9"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg9 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val9);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Period *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Handle< YieldTermStructure > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SwaptionHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwaptionHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "5"" of type '" "Period const &""'"); 
  }
  arg5 = reinterpret_cast< Period * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwaptionHelper" "', argument " "8"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< YieldTermStructure > * >(argp8);
  {
    try {
      result = (SwaptionHelper *)new SwaptionHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< IborIndex > const &)*arg4,(Period const &)*arg5,(DayCounter const &)*arg6,(DayCounter const &)*arg7,(Handle< YieldTermStructure > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwaptionHelper > *smartresult = result ? new ext::shared_ptr<  SwaptionHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwaptionHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[14] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwaptionHelper", 0, 13, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_SwaptionHelper__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_SwaptionHelper__SWIG_11(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_SwaptionHelper__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SwaptionHelper__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SwaptionHelper__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SwaptionHelper__SWIG_10(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_SwaptionHelper__SWIG_15(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_SwaptionHelper__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_SwaptionHelper__SWIG_9(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SwaptionHelper__SWIG_8(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SwaptionHelper__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SwaptionHelper__SWIG_14(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SwaptionHelper__SWIG_7(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SwaptionHelper__SWIG_13(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SwaptionHelper__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_SwaptionHelper__SWIG_12(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_SwaptionHelper__SWIG_6(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_SwaptionHelper__SWIG_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwaptionHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwaptionHelper::SwaptionHelper(Period const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const,VolatilityType const,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Period const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const,VolatilityType const)\n"
    "    SwaptionHelper::SwaptionHelper(Period const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Period const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Period const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType)\n"
    "    SwaptionHelper::SwaptionHelper(Period const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const,VolatilityType const,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const,VolatilityType const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const,VolatilityType const,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const,VolatilityType const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,Real const)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType)\n"
    "    SwaptionHelper::SwaptionHelper(Date const &,Date const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Period const &,DayCounter const &,DayCounter const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_underlyingSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper const > tempshared1 ;
  ext::shared_ptr< SwaptionHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< VanillaSwap > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_underlyingSwap" "', argument " "1"" of type '" "SwaptionHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwaptionHelper const *)arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwap > *smartresult = result ? new ext::shared_ptr<  VanillaSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper const > tempshared1 ;
  ext::shared_ptr< SwaptionHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Swaption > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_swaption" "', argument " "1"" of type '" "SwaptionHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((SwaptionHelper const *)arg1)->swaption();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ext::shared_ptr< Swaption >(result)), SWIGTYPE_p_ext__shared_ptrT_Swaption_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper > tempshared1 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_times" "', argument " "1"" of type '" "SwaptionHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = SwaptionHelper_times(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaptionExpiryDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper > tempshared1 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_swaptionExpiryDate" "', argument " "1"" of type '" "SwaptionHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = SwaptionHelper_swaptionExpiryDate(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaptionStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper > tempshared1 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_swaptionStrike" "', argument " "1"" of type '" "SwaptionHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)SwaptionHelper_swaptionStrike(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaptionNominal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper > tempshared1 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_swaptionNominal" "', argument " "1"" of type '" "SwaptionHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)SwaptionHelper_swaptionNominal(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwaptionHelper_swaptionMaturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper > tempshared1 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwaptionHelper_swaptionMaturityDate" "', argument " "1"" of type '" "SwaptionHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = SwaptionHelper_swaptionMaturityDate(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwaptionHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwaptionHelper *arg1 = (SwaptionHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwaptionHelper > tempshared1 ;
  ext::shared_ptr< SwaptionHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwaptionHelper" "', argument " "1"" of type '" "SwaptionHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwaptionHelper > * >(argp1);
      arg1 = const_cast< SwaptionHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwaptionHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwaptionHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwaptionHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CapHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  CapHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CapHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CapHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CapHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CapHelper" "', argument " "8"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg8 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CapHelper" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CapHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > const &)*arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapHelper > *smartresult = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  VolatilityType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  CapHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CapHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CapHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CapHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CapHelper" "', argument " "8"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg8 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CapHelper" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapHelper > *smartresult = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  CapHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CapHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CapHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CapHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CapHelper" "', argument " "8"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg8 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val8);
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapHelper > *smartresult = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Frequency arg4 ;
  DayCounter *arg5 = 0 ;
  bool arg6 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  CapHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CapHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CapHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CapHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    try {
      result = (CapHelper *)new CapHelper((Period const &)*arg1,(Handle< Quote > const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,(DayCounter const &)*arg5,arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapHelper > *smartresult = result ? new ext::shared_ptr<  CapHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CapHelper", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CapHelper__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CapHelper__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CapHelper__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_CapHelper__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CapHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CapHelper::CapHelper(Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Frequency,DayCounter const &,bool,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,VolatilityType const,Real const)\n"
    "    CapHelper::CapHelper(Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Frequency,DayCounter const &,bool,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType,VolatilityType const)\n"
    "    CapHelper::CapHelper(Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Frequency,DayCounter const &,bool,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType)\n"
    "    CapHelper::CapHelper(Period const &,Handle< Quote > const &,ext::shared_ptr< IborIndex > const &,Frequency,DayCounter const &,bool,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CapHelper_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapHelper *arg1 = (CapHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapHelper > tempshared1 ;
  ext::shared_ptr< CapHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapHelper_times" "', argument " "1"" of type '" "CapHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapHelper > * >(argp1);
      arg1 = const_cast< CapHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapHelper > * >(argp1);
      arg1 = const_cast< CapHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapHelper_times(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CapHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapHelper *arg1 = (CapHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapHelper > tempshared1 ;
  ext::shared_ptr< CapHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapHelper" "', argument " "1"" of type '" "CapHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapHelper > * >(argp1);
      arg1 = const_cast< CapHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapHelper > * >(argp1);
      arg1 = const_cast< CapHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CapHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CapHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CapHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonModelHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Handle< Quote > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  BlackCalibrationHelper::CalibrationErrorType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  HestonModelHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonModelHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonModelHelper" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HestonModelHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HestonModelHelper" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_HestonModelHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_HestonModelHelper" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_HestonModelHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HestonModelHelper" "', argument " "8"" of type '" "BlackCalibrationHelper::CalibrationErrorType""'");
  } 
  arg8 = static_cast< BlackCalibrationHelper::CalibrationErrorType >(val8);
  {
    try {
      result = (HestonModelHelper *)new HestonModelHelper((Period const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(Handle< Quote > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonModelHelper > *smartresult = result ? new ext::shared_ptr<  HestonModelHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonModelHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonModelHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Handle< Quote > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  HestonModelHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonModelHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonModelHelper" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HestonModelHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HestonModelHelper" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_HestonModelHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_HestonModelHelper" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_HestonModelHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonModelHelper" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    try {
      result = (HestonModelHelper *)new HestonModelHelper((Period const &)*arg1,(Calendar const &)*arg2,arg3,arg4,(Handle< Quote > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonModelHelper > *smartresult = result ? new ext::shared_ptr<  HestonModelHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonModelHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonModelHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonModelHelper", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_HestonModelHelper__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_HestonModelHelper__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonModelHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonModelHelper::HestonModelHelper(Period const &,Calendar const &,Real const,Real const,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,BlackCalibrationHelper::CalibrationErrorType)\n"
    "    HestonModelHelper::HestonModelHelper(Period const &,Calendar const &,Real const,Real const,Handle< Quote > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HestonModelHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonModelHelper *arg1 = (HestonModelHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonModelHelper > tempshared1 ;
  ext::shared_ptr< HestonModelHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonModelHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonModelHelper" "', argument " "1"" of type '" "HestonModelHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonModelHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonModelHelper > * >(argp1);
      arg1 = const_cast< HestonModelHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonModelHelper > * >(argp1);
      arg1 = const_cast< HestonModelHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonModelHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HestonModelHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonModelHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____bool__((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____len__((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalibrationHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackCalibrationHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BlackCalibrationHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BlackCalibrationHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__setslice__(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__setslice__(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalibrationHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BlackCalibrationHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BlackCalibrationHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__delitem__(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCalibrationHelper > *smartresult = *result ? new ext::shared_ptr<  BlackCalibrationHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BlackCalibrationHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BlackCalibrationHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__getitem__(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackCalibrationHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BlackCalibrationHelper > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BlackCalibrationHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BlackCalibrationHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BlackCalibrationHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::__setitem__(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCalibrationHelper > *smartresult = result ? new ext::shared_ptr<  BlackCalibrationHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackCalibrationHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__append(arg1,(ext::shared_ptr< BlackCalibrationHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCalibrationHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)new std::vector< ext::shared_ptr< BlackCalibrationHelper > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCalibrationHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)new std::vector< ext::shared_ptr< BlackCalibrationHelper > >((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackCalibrationHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlackCalibrationHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< BlackCalibrationHelper > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCalibrationHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BlackCalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)new std::vector< ext::shared_ptr< BlackCalibrationHelper > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_BlackCalibrationHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_BlackCalibrationHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::erase(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::erase(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BlackCalibrationHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg1 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BlackCalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCalibrationHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *)new std::vector< ext::shared_ptr< BlackCalibrationHelper > >(arg1,(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCalibrationHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackCalibrationHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BlackCalibrationHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BlackCalibrationHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BlackCalibrationHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BlackCalibrationHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackCalibrationHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::vector()\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::vector(std::vector< ext::shared_ptr< BlackCalibrationHelper > > const &)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::vector(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::vector(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlackCalibrationHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *) &((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCalibrationHelper > *smartresult = *result ? new ext::shared_ptr<  BlackCalibrationHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *) &((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCalibrationHelper > *smartresult = *result ? new ext::shared_ptr<  BlackCalibrationHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackCalibrationHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackCalibrationHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BlackCalibrationHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BlackCalibrationHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::resize(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::resize(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BlackCalibrationHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg3 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlackCalibrationHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BlackCalibrationHelper_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< BlackCalibrationHelper > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BlackCalibrationHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_BlackCalibrationHelper_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BlackCalibrationHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlackCalibrationHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::insert(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< BlackCalibrationHelper > >::insert(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type,std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BlackCalibrationHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlackCalibrationHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCalibrationHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCalibrationHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BlackCalibrationHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackCalibrationHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BlackCalibrationHelper > > *arg1 = (std::vector< ext::shared_ptr< BlackCalibrationHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackCalibrationHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackCalibrationHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BlackCalibrationHelper_t_std__allocatorT_ext__shared_ptrT_BlackCalibrationHelper_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackCalibrationHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Volatility result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CapFloor_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CapFloor_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CapFloor_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CapFloor_impliedVolatility" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CapFloor_impliedVolatility" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Volatility result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CapFloor_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CapFloor_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CapFloor_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CapFloor_impliedVolatility" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Volatility result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CapFloor_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CapFloor_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CapFloor_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CapFloor_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CapFloor_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CapFloor_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CapFloor_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_impliedVolatility" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloor_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloor_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  {
    try {
      result = (Volatility)((CapFloor const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CapFloor_impliedVolatility", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloor_impliedVolatility__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CapFloor_impliedVolatility__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CapFloor_impliedVolatility__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CapFloor_impliedVolatility__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_CapFloor_impliedVolatility__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_CapFloor_impliedVolatility__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_CapFloor_impliedVolatility__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CapFloor_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility,Volatility,VolatilityType,Real) const\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility,Volatility,VolatilityType) const\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility,Volatility) const\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility) const\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural) const\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real) const\n"
    "    CapFloor::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CapFloor_floatingLeg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Leg *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_floatingLeg" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Leg *) &((CapFloor const *)arg1)->floatingLeg();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_capRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_capRates" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &(arg1)->capRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_floorRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_floorRates" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &(arg1)->floorRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_startDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_startDate" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CapFloor const *)arg1)->startDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_maturityDate" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CapFloor const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  CapFloor::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_type" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (CapFloor::Type)((CapFloor const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_atmRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  YieldTermStructure *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor const > tempshared1 ;
  ext::shared_ptr< CapFloor const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure const > tempshared2 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CapFloor_atmRate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_atmRate" "', argument " "1"" of type '" "CapFloor const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloor_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloor_atmRate" "', argument " "2"" of type '" "YieldTermStructure const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2);
      arg2 = const_cast< YieldTermStructure * >(tempshared2.get());
    } else {
      arg2 = const_cast< YieldTermStructure * >(reinterpret_cast< ext::shared_ptr< const YieldTermStructure > * >(argp2)->get());
    }
  }
  {
    try {
      result = (Rate)((CapFloor const *)arg1)->atmRate((YieldTermStructure const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_vega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_vega" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)CapFloor_vega(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_optionletsPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_optionletsPrice" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapFloor_optionletsPrice(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_optionletsVega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_optionletsVega" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapFloor_optionletsVega(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_optionletsDelta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_optionletsDelta" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapFloor_optionletsDelta(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_optionletsDiscountFactor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_optionletsDiscountFactor" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapFloor_optionletsDiscountFactor(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_optionletsAtmForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_optionletsAtmForward" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapFloor_optionletsAtmForward(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloor_optionletsStdDev(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloor_optionletsStdDev" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CapFloor_optionletsStdDev(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CapFloor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloor *arg1 = (CapFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloor > tempshared1 ;
  ext::shared_ptr< CapFloor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapFloor" "', argument " "1"" of type '" "CapFloor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloor > * >(argp1);
      arg1 = const_cast< CapFloor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CapFloor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CapFloor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Cap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Cap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Cap", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Cap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Cap" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Cap" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Cap *)new Cap((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Cap > *smartresult = result ? new ext::shared_ptr<  Cap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Cap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Cap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Cap *arg1 = (Cap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Cap > tempshared1 ;
  ext::shared_ptr< Cap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Cap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cap" "', argument " "1"" of type '" "Cap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Cap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Cap > * >(argp1);
      arg1 = const_cast< Cap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Cap > * >(argp1);
      arg1 = const_cast< Cap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Cap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Cap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Cap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Floor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Floor *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Floor", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Floor" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Floor" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Floor" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Floor" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Floor *)new Floor((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Floor > *smartresult = result ? new ext::shared_ptr<  Floor >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Floor_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Floor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Floor *arg1 = (Floor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Floor > tempshared1 ;
  ext::shared_ptr< Floor > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Floor_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Floor" "', argument " "1"" of type '" "Floor *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Floor > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Floor > * >(argp1);
      arg1 = const_cast< Floor * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Floor > * >(argp1);
      arg1 = const_cast< Floor * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Floor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Floor_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Floor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Collar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Collar *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Collar", 3, 3, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *ptr = (std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Collar" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Collar" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Collar" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Collar" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Collar" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Collar" "', argument " "3"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Collar *)new Collar((std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(std::vector< Rate,std::allocator< Rate > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Collar > *smartresult = result ? new ext::shared_ptr<  Collar >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Collar_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Collar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Collar *arg1 = (Collar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Collar > tempshared1 ;
  ext::shared_ptr< Collar > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Collar_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Collar" "', argument " "1"" of type '" "Collar *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Collar > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Collar > * >(argp1);
      arg1 = const_cast< Collar * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Collar > * >(argp1);
      arg1 = const_cast< Collar * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Collar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Collar_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Collar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackCapFloorEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackCapFloorEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BlackCapFloorEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCapFloorEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackCapFloorEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCapFloorEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCapFloorEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlackCapFloorEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< OptionletVolatilityStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCapFloorEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BlackCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCapFloorEngine" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp2);
  {
    try {
      result = (BlackCapFloorEngine *)new BlackCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BlackCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackCapFloorEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackCapFloorEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BlackCapFloorEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BlackCapFloorEngine__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BlackCapFloorEngine__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BlackCapFloorEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_BlackCapFloorEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackCapFloorEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackCapFloorEngine::BlackCapFloorEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &,DayCounter const &,Real)\n"
    "    BlackCapFloorEngine::BlackCapFloorEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    BlackCapFloorEngine::BlackCapFloorEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &)\n"
    "    BlackCapFloorEngine::BlackCapFloorEngine(Handle< YieldTermStructure > const &,Handle< OptionletVolatilityStructure > const &,Real)\n"
    "    BlackCapFloorEngine::BlackCapFloorEngine(Handle< YieldTermStructure > const &,Handle< OptionletVolatilityStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCapFloorEngine *arg1 = (BlackCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCapFloorEngine > tempshared1 ;
  ext::shared_ptr< BlackCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackCapFloorEngine" "', argument " "1"" of type '" "BlackCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCapFloorEngine > * >(argp1);
      arg1 = const_cast< BlackCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCapFloorEngine > * >(argp1);
      arg1 = const_cast< BlackCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BachelierCapFloorEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BachelierCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BachelierCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BachelierCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierCapFloorEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (BachelierCapFloorEngine *)new BachelierCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BachelierCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BachelierCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BachelierCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BachelierCapFloorEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< OptionletVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BachelierCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BachelierCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierCapFloorEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BachelierCapFloorEngine" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierCapFloorEngine" "', argument " "2"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp2);
  {
    try {
      result = (BachelierCapFloorEngine *)new BachelierCapFloorEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< OptionletVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BachelierCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  BachelierCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BachelierCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BachelierCapFloorEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BachelierCapFloorEngine", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BachelierCapFloorEngine__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BachelierCapFloorEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BachelierCapFloorEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BachelierCapFloorEngine::BachelierCapFloorEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &)\n"
    "    BachelierCapFloorEngine::BachelierCapFloorEngine(Handle< YieldTermStructure > const &,Handle< OptionletVolatilityStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BachelierCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BachelierCapFloorEngine *arg1 = (BachelierCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BachelierCapFloorEngine > tempshared1 ;
  ext::shared_ptr< BachelierCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BachelierCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BachelierCapFloorEngine" "', argument " "1"" of type '" "BachelierCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BachelierCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BachelierCapFloorEngine > * >(argp1);
      arg1 = const_cast< BachelierCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BachelierCapFloorEngine > * >(argp1);
      arg1 = const_cast< BachelierCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BachelierCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BachelierCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BachelierCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CliquetOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PercentageStrikePayoff > *arg1 = 0 ;
  ext::shared_ptr< EuropeanExercise > *arg2 = 0 ;
  std::vector< Date,std::allocator< Date > > arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PercentageStrikePayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< EuropeanExercise > tempshared2 ;
  PyObject *swig_obj[3] ;
  CliquetOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CliquetOption", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PercentageStrikePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CliquetOption" "', argument " "1"" of type '" "ext::shared_ptr< PercentageStrikePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PercentageStrikePayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PercentageStrikePayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PercentageStrikePayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_EuropeanExercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CliquetOption" "', argument " "2"" of type '" "ext::shared_ptr< EuropeanExercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< EuropeanExercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< EuropeanExercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< EuropeanExercise > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CliquetOption" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (CliquetOption *)new CliquetOption((ext::shared_ptr< PercentageStrikePayoff > const &)*arg1,(ext::shared_ptr< EuropeanExercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CliquetOption > *smartresult = result ? new ext::shared_ptr<  CliquetOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CliquetOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CliquetOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CliquetOption *arg1 = (CliquetOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CliquetOption > tempshared1 ;
  ext::shared_ptr< CliquetOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CliquetOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CliquetOption" "', argument " "1"" of type '" "CliquetOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CliquetOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CliquetOption > * >(argp1);
      arg1 = const_cast< CliquetOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CliquetOption > * >(argp1);
      arg1 = const_cast< CliquetOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CliquetOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CliquetOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CliquetOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticCliquetEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticCliquetEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticCliquetEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticCliquetEngine *)new AnalyticCliquetEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticCliquetEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticCliquetEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticCliquetEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticCliquetEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticCliquetEngine *arg1 = (AnalyticCliquetEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticCliquetEngine > tempshared1 ;
  ext::shared_ptr< AnalyticCliquetEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticCliquetEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticCliquetEngine" "', argument " "1"" of type '" "AnalyticCliquetEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticCliquetEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticCliquetEngine > * >(argp1);
      arg1 = const_cast< AnalyticCliquetEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticCliquetEngine > * >(argp1);
      arg1 = const_cast< AnalyticCliquetEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticCliquetEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticCliquetEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticCliquetEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticPerformanceEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  AnalyticPerformanceEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticPerformanceEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  {
    try {
      result = (AnalyticPerformanceEngine *)new AnalyticPerformanceEngine(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticPerformanceEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticPerformanceEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticPerformanceEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticPerformanceEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticPerformanceEngine *arg1 = (AnalyticPerformanceEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticPerformanceEngine > tempshared1 ;
  ext::shared_ptr< AnalyticPerformanceEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticPerformanceEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticPerformanceEngine" "', argument " "1"" of type '" "AnalyticPerformanceEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticPerformanceEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticPerformanceEngine > * >(argp1);
      arg1 = const_cast< AnalyticPerformanceEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticPerformanceEngine > * >(argp1);
      arg1 = const_cast< AnalyticPerformanceEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticPerformanceEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticPerformanceEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticPerformanceEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCPRPerformanceEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCPerformanceEngine< PseudoRandom > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCPRPerformanceEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCPRPerformanceEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCPRPerformanceEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCPRPerformanceEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCPRPerformanceEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCPerformanceEngine< PseudoRandom > *)new_MCPerformanceEngine_Sl_PseudoRandom_Sg_(SWIG_STD_MOVE(arg1),arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> > *smartresult = result ? new ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_PseudoRandom_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCPRPerformanceEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCPerformanceEngine< PseudoRandom > *arg1 = (MCPerformanceEngine< PseudoRandom > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCPerformanceEngine< PseudoRandom > > tempshared1 ;
  ext::shared_ptr< MCPerformanceEngine< PseudoRandom > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_PseudoRandom_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCPRPerformanceEngine" "', argument " "1"" of type '" "MCPerformanceEngine< PseudoRandom > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCPerformanceEngine< PseudoRandom > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCPerformanceEngine<PseudoRandom> > * >(argp1);
      arg1 = const_cast< MCPerformanceEngine< PseudoRandom > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCPRPerformanceEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_PseudoRandom_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCPRPerformanceEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MCLDPerformanceEngine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  bool arg2 = (bool) false ;
  bool arg3 = (bool) false ;
  intOrNull arg4 = (intOrNull) Null< Size >() ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  intOrNull arg6 = (intOrNull) Null< Size >() ;
  BigInteger arg7 = (BigInteger) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  long val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"brownianBridge",  (char *)"antitheticVariate",  (char *)"requiredSamples",  (char *)"requiredTolerance",  (char *)"maxSamples",  (char *)"seed",  NULL 
  };
  MCPerformanceEngine< LowDiscrepancy > *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOOOO:new_MCLDPerformanceEngine", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MCLDPerformanceEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MCLDPerformanceEngine" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_bool(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MCLDPerformanceEngine" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
  }
  if (obj3) {
    {
      if (obj3 == Py_None)
      arg4 = Null<int>();
      else if (PyInt_Check(obj3))
      arg4 = int(PyInt_AsLong(obj3));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<int>();
      else if (PyInt_Check(obj5))
      arg6 = int(PyInt_AsLong(obj5));
      else
      SWIG_exception(SWIG_TypeError,"int expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_long(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MCLDPerformanceEngine" "', argument " "7"" of type '" "BigInteger""'");
    } 
    arg7 = static_cast< BigInteger >(val7);
  }
  {
    try {
      result = (MCPerformanceEngine< LowDiscrepancy > *)new_MCPerformanceEngine_Sl_LowDiscrepancy_Sg_(SWIG_STD_MOVE(arg1),arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> > *smartresult = result ? new ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_LowDiscrepancy_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MCLDPerformanceEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MCPerformanceEngine< LowDiscrepancy > *arg1 = (MCPerformanceEngine< LowDiscrepancy > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MCPerformanceEngine< LowDiscrepancy > > tempshared1 ;
  ext::shared_ptr< MCPerformanceEngine< LowDiscrepancy > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_LowDiscrepancy_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MCLDPerformanceEngine" "', argument " "1"" of type '" "MCPerformanceEngine< LowDiscrepancy > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCPerformanceEngine< LowDiscrepancy > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MCPerformanceEngine<LowDiscrepancy> > * >(argp1);
      arg1 = const_cast< MCPerformanceEngine< LowDiscrepancy > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MCLDPerformanceEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MCPerformanceEngineT_LowDiscrepancy_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MCLDPerformanceEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConvertibleZeroCouponBond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  Real arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  ConvertibleZeroCouponBond *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (ConvertibleZeroCouponBond *)new ConvertibleZeroCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleZeroCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleZeroCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleZeroCouponBond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  DayCounter *arg6 = 0 ;
  Schedule *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ConvertibleZeroCouponBond *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleZeroCouponBond" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleZeroCouponBond" "', argument " "7"" of type '" "Schedule const &""'"); 
  }
  arg7 = reinterpret_cast< Schedule * >(argp7);
  {
    try {
      result = (ConvertibleZeroCouponBond *)new ConvertibleZeroCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(DayCounter const &)*arg6,(Schedule const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleZeroCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleZeroCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleZeroCouponBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvertibleZeroCouponBond", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ConvertibleZeroCouponBond__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ConvertibleZeroCouponBond__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvertibleZeroCouponBond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConvertibleZeroCouponBond::ConvertibleZeroCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,DayCounter const &,Schedule const &,Real)\n"
    "    ConvertibleZeroCouponBond::ConvertibleZeroCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,DayCounter const &,Schedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvertibleZeroCouponBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConvertibleZeroCouponBond *arg1 = (ConvertibleZeroCouponBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConvertibleZeroCouponBond > tempshared1 ;
  ext::shared_ptr< ConvertibleZeroCouponBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvertibleZeroCouponBond" "', argument " "1"" of type '" "ConvertibleZeroCouponBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConvertibleZeroCouponBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConvertibleZeroCouponBond > * >(argp1);
      arg1 = const_cast< ConvertibleZeroCouponBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConvertibleZeroCouponBond > * >(argp1);
      arg1 = const_cast< ConvertibleZeroCouponBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConvertibleZeroCouponBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConvertibleZeroCouponBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConvertibleZeroCouponBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  bool arg13 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  arg11 = reinterpret_cast< Calendar * >(argp11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "BusinessDayConvention""'");
  } 
  arg12 = static_cast< BusinessDayConvention >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,arg9,(Period const &)*arg10,(Calendar const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFixedCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  BusinessDayConvention arg12 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  arg11 = reinterpret_cast< Calendar * >(argp11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "12"" of type '" "BusinessDayConvention""'");
  } 
  arg12 = static_cast< BusinessDayConvention >(val12);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,arg9,(Period const &)*arg10,(Calendar const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFixedCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  Calendar *arg11 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "11"" of type '" "Calendar const &""'"); 
  }
  arg11 = reinterpret_cast< Calendar * >(argp11);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,arg9,(Period const &)*arg10,(Calendar const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFixedCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  Period *arg10 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "10"" of type '" "Period const &""'"); 
  }
  arg10 = reinterpret_cast< Period * >(argp10);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,arg9,(Period const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFixedCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFixedCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  Schedule *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  ConvertibleFixedCouponBond *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFixedCouponBond" "', argument " "8"" of type '" "Schedule const &""'"); 
  }
  arg8 = reinterpret_cast< Schedule * >(argp8);
  {
    try {
      result = (ConvertibleFixedCouponBond *)new ConvertibleFixedCouponBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,(DayCounter const &)*arg7,(Schedule const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFixedCouponBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFixedCouponBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFixedCouponBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[14] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvertibleFixedCouponBond", 0, 13, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_ConvertibleFixedCouponBond__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ConvertibleFixedCouponBond__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_ConvertibleFixedCouponBond__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_ConvertibleFixedCouponBond__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_ConvertibleFixedCouponBond__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_ConvertibleFixedCouponBond__SWIG_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvertibleFixedCouponBond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConvertibleFixedCouponBond::ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &,Real,Period const &,Calendar const &,BusinessDayConvention const,bool)\n"
    "    ConvertibleFixedCouponBond::ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &,Real,Period const &,Calendar const &,BusinessDayConvention const)\n"
    "    ConvertibleFixedCouponBond::ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &,Real,Period const &,Calendar const &)\n"
    "    ConvertibleFixedCouponBond::ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &,Real,Period const &)\n"
    "    ConvertibleFixedCouponBond::ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &,Real)\n"
    "    ConvertibleFixedCouponBond::ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Schedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvertibleFixedCouponBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConvertibleFixedCouponBond *arg1 = (ConvertibleFixedCouponBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConvertibleFixedCouponBond > tempshared1 ;
  ext::shared_ptr< ConvertibleFixedCouponBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvertibleFixedCouponBond" "', argument " "1"" of type '" "ConvertibleFixedCouponBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConvertibleFixedCouponBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConvertibleFixedCouponBond > * >(argp1);
      arg1 = const_cast< ConvertibleFixedCouponBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConvertibleFixedCouponBond > * >(argp1);
      arg1 = const_cast< ConvertibleFixedCouponBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConvertibleFixedCouponBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConvertibleFixedCouponBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConvertibleFixedCouponBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  bool arg15 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  arg12 = reinterpret_cast< Period * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  arg13 = reinterpret_cast< Calendar * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "BusinessDayConvention""'");
  } 
  arg14 = static_cast< BusinessDayConvention >(val14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread,std::allocator< Spread > > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  BusinessDayConvention arg14 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  arg12 = reinterpret_cast< Period * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  arg13 = reinterpret_cast< Calendar * >(argp13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "14"" of type '" "BusinessDayConvention""'");
  } 
  arg14 = static_cast< BusinessDayConvention >(val14);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread,std::allocator< Spread > > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period const &)*arg12,(Calendar const &)*arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  Calendar *arg13 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  arg12 = reinterpret_cast< Period * >(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "13"" of type '" "Calendar const &""'"); 
  }
  arg13 = reinterpret_cast< Calendar * >(argp13);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread,std::allocator< Spread > > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period const &)*arg12,(Calendar const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  Period *arg12 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "12"" of type '" "Period const &""'"); 
  }
  arg12 = reinterpret_cast< Period * >(argp12);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread,std::allocator< Spread > > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11,(Period const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  Real arg11 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread,std::allocator< Spread > > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Exercise > *arg1 = 0 ;
  Real arg2 ;
  std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Integer arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Integer arg7 ;
  std::vector< Spread,std::allocator< Spread > > *arg8 = 0 ;
  DayCounter *arg9 = 0 ;
  Schedule *arg10 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Exercise > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  ConvertibleFloatingRateBond *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *ptr = (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "5"" of type '" "Integer""'");
  } 
  arg5 = static_cast< Integer >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "7"" of type '" "Integer""'");
  } 
  arg7 = static_cast< Integer >(val7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "8"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg8 = ptr;
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvertibleFloatingRateBond" "', argument " "10"" of type '" "Schedule const &""'"); 
  }
  arg10 = reinterpret_cast< Schedule * >(argp10);
  {
    try {
      result = (ConvertibleFloatingRateBond *)new ConvertibleFloatingRateBond((ext::shared_ptr< Exercise > const &)*arg1,arg2,(std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &)*arg3,(Date const &)*arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,arg7,(std::vector< Spread,std::allocator< Spread > > const &)*arg8,(DayCounter const &)*arg9,(Schedule const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConvertibleFloatingRateBond > *smartresult = result ? new ext::shared_ptr<  ConvertibleFloatingRateBond >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConvertibleFloatingRateBond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvertibleFloatingRateBond", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_ConvertibleFloatingRateBond__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ConvertibleFloatingRateBond__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_ConvertibleFloatingRateBond__SWIG_3(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_ConvertibleFloatingRateBond__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_ConvertibleFloatingRateBond__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_ConvertibleFloatingRateBond__SWIG_0(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvertibleFloatingRateBond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ConvertibleFloatingRateBond::ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,ext::shared_ptr< IborIndex > const &,Integer,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,Schedule const &,Real,Period const &,Calendar const &,BusinessDayConvention const,bool)\n"
    "    ConvertibleFloatingRateBond::ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,ext::shared_ptr< IborIndex > const &,Integer,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,Schedule const &,Real,Period const &,Calendar const &,BusinessDayConvention const)\n"
    "    ConvertibleFloatingRateBond::ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,ext::shared_ptr< IborIndex > const &,Integer,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,Schedule const &,Real,Period const &,Calendar const &)\n"
    "    ConvertibleFloatingRateBond::ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,ext::shared_ptr< IborIndex > const &,Integer,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,Schedule const &,Real,Period const &)\n"
    "    ConvertibleFloatingRateBond::ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,ext::shared_ptr< IborIndex > const &,Integer,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,Schedule const &,Real)\n"
    "    ConvertibleFloatingRateBond::ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const &,Real,std::vector< ext::shared_ptr< Callability >,std::allocator< ext::shared_ptr< Callability > > > const &,Date const &,Integer,ext::shared_ptr< IborIndex > const &,Integer,std::vector< Spread,std::allocator< Spread > > const &,DayCounter const &,Schedule const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConvertibleFloatingRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConvertibleFloatingRateBond *arg1 = (ConvertibleFloatingRateBond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConvertibleFloatingRateBond > tempshared1 ;
  ext::shared_ptr< ConvertibleFloatingRateBond > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvertibleFloatingRateBond" "', argument " "1"" of type '" "ConvertibleFloatingRateBond *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConvertibleFloatingRateBond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConvertibleFloatingRateBond > * >(argp1);
      arg1 = const_cast< ConvertibleFloatingRateBond * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConvertibleFloatingRateBond > * >(argp1);
      arg1 = const_cast< ConvertibleFloatingRateBond * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConvertibleFloatingRateBond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConvertibleFloatingRateBond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConvertibleFloatingRateBond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialCRRConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< CoxRossRubinstein > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< CoxRossRubinstein > *)new BinomialConvertibleEngine< CoxRossRubinstein >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialCRRConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< CoxRossRubinstein > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialCRRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< CoxRossRubinstein > *)new BinomialConvertibleEngine< CoxRossRubinstein >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialCRRConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialCRRConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialCRRConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialCRRConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialCRRConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< CoxRossRubinstein >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< CoxRossRubinstein >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialCRRConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< CoxRossRubinstein > *arg1 = (BinomialConvertibleEngine< CoxRossRubinstein > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialCRRConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< CoxRossRubinstein > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< CoxRossRubinstein > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<CoxRossRubinstein> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< CoxRossRubinstein > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialCRRConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialCRRConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJRConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< JarrowRudd > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialJRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialJRConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< JarrowRudd > *)new BinomialConvertibleEngine< JarrowRudd >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJRConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< JarrowRudd > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialJRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialJRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< JarrowRudd > *)new BinomialConvertibleEngine< JarrowRudd >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJRConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialJRConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialJRConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialJRConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialJRConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< JarrowRudd >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< JarrowRudd >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJRConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< JarrowRudd > *arg1 = (BinomialConvertibleEngine< JarrowRudd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJRConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< JarrowRudd > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< JarrowRudd > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<JarrowRudd> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< JarrowRudd > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJRConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJRConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialEQPConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *)new BinomialConvertibleEngine< AdditiveEQPBinomialTree >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialEQPConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialEQPConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *)new BinomialConvertibleEngine< AdditiveEQPBinomialTree >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialEQPConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialEQPConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialEQPConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialEQPConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialEQPConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< AdditiveEQPBinomialTree >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< AdditiveEQPBinomialTree >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialEQPConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< AdditiveEQPBinomialTree > *arg1 = (BinomialConvertibleEngine< AdditiveEQPBinomialTree > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialEQPConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< AdditiveEQPBinomialTree > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< AdditiveEQPBinomialTree > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<AdditiveEQPBinomialTree> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< AdditiveEQPBinomialTree > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialEQPConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialEQPConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< Trigeorgis > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< Trigeorgis > *)new BinomialConvertibleEngine< Trigeorgis >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< Trigeorgis > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialTrigeorgisConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< Trigeorgis > *)new BinomialConvertibleEngine< Trigeorgis >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTrigeorgisConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialTrigeorgisConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialTrigeorgisConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialTrigeorgisConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialTrigeorgisConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< Trigeorgis >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< Trigeorgis >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTrigeorgisConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< Trigeorgis > *arg1 = (BinomialConvertibleEngine< Trigeorgis > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTrigeorgisConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< Trigeorgis > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< Trigeorgis > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Trigeorgis> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< Trigeorgis > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTrigeorgisConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTrigeorgisConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialTianConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< Tian > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialTianConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialTianConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< Tian > *)new BinomialConvertibleEngine< Tian >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<Tian> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Tian> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTianConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< Tian > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialTianConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialTianConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< Tian > *)new BinomialConvertibleEngine< Tian >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<Tian> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Tian> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialTianConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialTianConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialTianConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialTianConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialTianConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< Tian >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< Tian >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialTianConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< Tian > *arg1 = (BinomialConvertibleEngine< Tian > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< Tian > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< Tian > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialTianConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< Tian > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Tian> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Tian> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< Tian > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Tian> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< Tian > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialTianConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialTianConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialLRConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< LeisenReimer > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialLRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialLRConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< LeisenReimer > *)new BinomialConvertibleEngine< LeisenReimer >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialLRConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< LeisenReimer > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialLRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialLRConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< LeisenReimer > *)new BinomialConvertibleEngine< LeisenReimer >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialLRConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialLRConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialLRConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialLRConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialLRConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< LeisenReimer >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< LeisenReimer >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialLRConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< LeisenReimer > *arg1 = (BinomialConvertibleEngine< LeisenReimer > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialLRConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< LeisenReimer > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< LeisenReimer > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<LeisenReimer> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< LeisenReimer > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialLRConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialLRConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialJ4ConvertibleEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  BinomialConvertibleEngine< Joshi4 > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (BinomialConvertibleEngine< Joshi4 > *)new BinomialConvertibleEngine< Joshi4 >(arg1,arg2,(Handle< Quote > const &)*arg3,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJ4ConvertibleEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > arg1 ;
  Size arg2 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BinomialConvertibleEngine< Joshi4 > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BinomialJ4ConvertibleEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (BinomialConvertibleEngine< Joshi4 > *)new BinomialConvertibleEngine< Joshi4 >(arg1,arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> > *smartresult = result ? new ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BinomialJ4ConvertibleEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BinomialJ4ConvertibleEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BinomialJ4ConvertibleEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_BinomialJ4ConvertibleEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BinomialJ4ConvertibleEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BinomialConvertibleEngine< Joshi4 >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &,std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)\n"
    "    BinomialConvertibleEngine< Joshi4 >::BinomialConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess >,Size,Handle< Quote > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BinomialJ4ConvertibleEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialConvertibleEngine< Joshi4 > *arg1 = (BinomialConvertibleEngine< Joshi4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > tempshared1 ;
  ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialJ4ConvertibleEngine" "', argument " "1"" of type '" "BinomialConvertibleEngine< Joshi4 > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< Joshi4 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BinomialConvertibleEngine<Joshi4> > * >(argp1);
      arg1 = const_cast< BinomialConvertibleEngine< Joshi4 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialJ4ConvertibleEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialJ4ConvertibleEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Forward_settlementDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_settlementDate" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Forward const *)arg1)->settlementDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_isExpired(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_isExpired" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((Forward const *)arg1)->isExpired();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Calendar *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_calendar" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Calendar *) &((Forward const *)arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Calendar, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_businessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_businessDayConvention" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)((Forward const *)arg1)->businessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  DayCounter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_dayCounter" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (DayCounter *) &((Forward const *)arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DayCounter, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_discountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_discountCurve" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Forward const *)arg1)->discountCurve();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_incomeDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_incomeDiscountCurve" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Forward const *)arg1)->incomeDiscountCurve();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_spotValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_spotValue" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((Forward const *)arg1)->spotValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_spotIncome(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward const > tempshared1 ;
  ext::shared_ptr< Forward const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Forward_spotIncome", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_spotIncome" "', argument " "1"" of type '" "Forward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Forward_spotIncome" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Forward_spotIncome" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  {
    try {
      result = (Real)((Forward const *)arg1)->spotIncome((Handle< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_forwardValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward > tempshared1 ;
  ext::shared_ptr< Forward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_forwardValue" "', argument " "1"" of type '" "Forward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->forwardValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Forward_impliedYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Date arg4 ;
  Compounding arg5 ;
  SwigValueWrapper< DayCounter > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward > tempshared1 ;
  ext::shared_ptr< Forward > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  InterestRate result;
  
  if (!SWIG_Python_UnpackTuple(args, "Forward_impliedYield", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Forward_impliedYield" "', argument " "1"" of type '" "Forward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Forward_impliedYield" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Forward_impliedYield" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Forward_impliedYield" "', argument " "4"" of type '" "Date""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Forward_impliedYield" "', argument " "4"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Forward_impliedYield" "', argument " "5"" of type '" "Compounding""'");
  } 
  arg5 = static_cast< Compounding >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Forward_impliedYield" "', argument " "6"" of type '" "DayCounter""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Forward_impliedYield" "', argument " "6"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (arg1)->impliedYield(arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Forward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Forward *arg1 = (Forward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Forward > tempshared1 ;
  ext::shared_ptr< Forward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Forward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Forward" "', argument " "1"" of type '" "Forward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      arg1 = const_cast< Forward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Forward > * >(argp1);
      arg1 = const_cast< Forward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Forward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Forward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BondForward__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< Bond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< Bond > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  BondForward *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BondForward" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BondForward" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BondForward" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_BondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_BondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_BondForward" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_BondForward" "', argument " "9"" of type '" "ext::shared_ptr< Bond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< Bond > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< Bond > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< Bond > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_BondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_BondForward" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  {
    try {
      result = (BondForward *)new BondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< Bond > const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondForward > *smartresult = result ? new ext::shared_ptr<  BondForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondForward__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< Bond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< Bond > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  BondForward *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BondForward" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BondForward" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BondForward" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_BondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_BondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_BondForward" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_BondForward" "', argument " "9"" of type '" "ext::shared_ptr< Bond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< Bond > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< Bond > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< Bond > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_BondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (BondForward *)new BondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< Bond > const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondForward > *smartresult = result ? new ext::shared_ptr<  BondForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondForward__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< Bond > *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< Bond > tempshared9 ;
  BondForward *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BondForward" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BondForward" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BondForward" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_BondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_BondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_BondForward" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_BondForward" "', argument " "9"" of type '" "ext::shared_ptr< Bond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< Bond > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< Bond > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< Bond > * >(argp9) : &tempshared9;
    }
  }
  {
    try {
      result = (BondForward *)new BondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< Bond > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondForward > *smartresult = result ? new ext::shared_ptr<  BondForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondForward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BondForward", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_BondForward__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_BondForward__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_BondForward__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BondForward'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondForward::BondForward(Date const &,Date const &,Position::Type,Real,Natural,DayCounter const &,Calendar const &,BusinessDayConvention,ext::shared_ptr< Bond > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n"
    "    BondForward::BondForward(Date const &,Date const &,Position::Type,Real,Natural,DayCounter const &,Calendar const &,BusinessDayConvention,ext::shared_ptr< Bond > const &,Handle< YieldTermStructure > const &)\n"
    "    BondForward::BondForward(Date const &,Date const &,Position::Type,Real,Natural,DayCounter const &,Calendar const &,BusinessDayConvention,ext::shared_ptr< Bond > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondForward_forwardPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondForward *arg1 = (BondForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BondForward > tempshared1 ;
  ext::shared_ptr< BondForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BondForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondForward_forwardPrice" "', argument " "1"" of type '" "BondForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      arg1 = const_cast< BondForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      arg1 = const_cast< BondForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->forwardPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondForward_cleanForwardPrice(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondForward *arg1 = (BondForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BondForward > tempshared1 ;
  ext::shared_ptr< BondForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BondForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondForward_cleanForwardPrice" "', argument " "1"" of type '" "BondForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      arg1 = const_cast< BondForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      arg1 = const_cast< BondForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->cleanForwardPrice();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BondForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondForward *arg1 = (BondForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BondForward > tempshared1 ;
  ext::shared_ptr< BondForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BondForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BondForward" "', argument " "1"" of type '" "BondForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      arg1 = const_cast< BondForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BondForward > * >(argp1);
      arg1 = const_cast< BondForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BondForward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BondForward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BondForward_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FixedRateBondForward__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< FixedRateBond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< FixedRateBond > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  FixedRateBondForward *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedRateBondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondForward" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FixedRateBondForward" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBondForward" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FixedRateBondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondForward" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondForward" "', argument " "9"" of type '" "ext::shared_ptr< FixedRateBond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBondForward" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  {
    try {
      result = (FixedRateBondForward *)new FixedRateBondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< FixedRateBond > const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondForward > *smartresult = result ? new ext::shared_ptr<  FixedRateBondForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondForward__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< FixedRateBond > *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< FixedRateBond > tempshared9 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  FixedRateBondForward *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedRateBondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondForward" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FixedRateBondForward" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBondForward" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FixedRateBondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondForward" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondForward" "', argument " "9"" of type '" "ext::shared_ptr< FixedRateBond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9) : &tempshared9;
    }
  }
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (FixedRateBondForward *)new FixedRateBondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< FixedRateBond > const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondForward > *smartresult = result ? new ext::shared_ptr<  FixedRateBondForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondForward__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Real arg4 ;
  Natural arg5 ;
  DayCounter *arg6 = 0 ;
  Calendar *arg7 = 0 ;
  BusinessDayConvention arg8 ;
  ext::shared_ptr< FixedRateBond > *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  ext::shared_ptr< FixedRateBond > tempshared9 ;
  FixedRateBondForward *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedRateBondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondForward" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FixedRateBondForward" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FixedRateBondForward" "', argument " "5"" of type '" "Natural""'");
  } 
  arg5 = static_cast< Natural >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FixedRateBondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondForward" "', argument " "7"" of type '" "Calendar const &""'"); 
  }
  arg7 = reinterpret_cast< Calendar * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondForward" "', argument " "8"" of type '" "BusinessDayConvention""'");
  } 
  arg8 = static_cast< BusinessDayConvention >(val8);
  {
    int newmem = 0;
    res9 = SWIG_ConvertPtrAndOwn(swig_obj[8], &argp9, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t,  0 , &newmem);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondForward" "', argument " "9"" of type '" "ext::shared_ptr< FixedRateBond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp9) tempshared9 = *reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9);
      delete reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9);
      arg9 = &tempshared9;
    } else {
      arg9 = (argp9) ? reinterpret_cast< ext::shared_ptr< FixedRateBond > * >(argp9) : &tempshared9;
    }
  }
  {
    try {
      result = (FixedRateBondForward *)new FixedRateBondForward((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(DayCounter const &)*arg6,(Calendar const &)*arg7,arg8,(ext::shared_ptr< FixedRateBond > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondForward > *smartresult = result ? new ext::shared_ptr<  FixedRateBondForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondForward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FixedRateBondForward", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_FixedRateBondForward__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FixedRateBondForward__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_FixedRateBondForward__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FixedRateBondForward'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FixedRateBondForward::FixedRateBondForward(Date const &,Date const &,Position::Type,Real,Natural,DayCounter const &,Calendar const &,BusinessDayConvention,ext::shared_ptr< FixedRateBond > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &)\n"
    "    FixedRateBondForward::FixedRateBondForward(Date const &,Date const &,Position::Type,Real,Natural,DayCounter const &,Calendar const &,BusinessDayConvention,ext::shared_ptr< FixedRateBond > const &,Handle< YieldTermStructure > const &)\n"
    "    FixedRateBondForward::FixedRateBondForward(Date const &,Date const &,Position::Type,Real,Natural,DayCounter const &,Calendar const &,BusinessDayConvention,ext::shared_ptr< FixedRateBond > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FixedRateBondForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateBondForward *arg1 = (FixedRateBondForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateBondForward > tempshared1 ;
  ext::shared_ptr< FixedRateBondForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateBondForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedRateBondForward" "', argument " "1"" of type '" "FixedRateBondForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedRateBondForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedRateBondForward > * >(argp1);
      arg1 = const_cast< FixedRateBondForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedRateBondForward > * >(argp1);
      arg1 = const_cast< FixedRateBondForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedRateBondForward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FixedRateBondForward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedRateBondForward_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Futures(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Futures *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Futures", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Futures *)new Futures();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Futures, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Futures(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Futures *arg1 = (Futures *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Futures, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Futures" "', argument " "1"" of type '" "Futures *""'"); 
  }
  arg1 = reinterpret_cast< Futures * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Futures_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Futures, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Futures_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OvernightIndexFuture__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OvernightIndex > arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Handle< Quote > arg4 ;
  RateAveraging::Type arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  OvernightIndexFuture *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexFuture" "', argument " "1"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexFuture" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexFuture" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexFuture" "', argument " "4"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "4"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_OvernightIndexFuture" "', argument " "5"" of type '" "RateAveraging::Type""'");
  } 
  arg5 = static_cast< RateAveraging::Type >(val5);
  {
    try {
      result = (OvernightIndexFuture *)new OvernightIndexFuture(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexFuture > *smartresult = result ? new ext::shared_ptr<  OvernightIndexFuture >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexFuture__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OvernightIndex > arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Handle< Quote > arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  OvernightIndexFuture *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexFuture" "', argument " "1"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexFuture" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexFuture" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexFuture" "', argument " "4"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "4"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (OvernightIndexFuture *)new OvernightIndexFuture(arg1,(Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexFuture > *smartresult = result ? new ext::shared_ptr<  OvernightIndexFuture >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexFuture__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< OvernightIndex > arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  OvernightIndexFuture *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexFuture" "', argument " "1"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexFuture" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexFuture" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFuture" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (OvernightIndexFuture *)new OvernightIndexFuture(arg1,(Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexFuture > *smartresult = result ? new ext::shared_ptr<  OvernightIndexFuture >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexFuture(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexFuture", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_OvernightIndexFuture__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_OvernightIndexFuture__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_OvernightIndexFuture__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIndexFuture'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIndexFuture::OvernightIndexFuture(ext::shared_ptr< OvernightIndex >,Date const &,Date const &,Handle< Quote >,RateAveraging::Type)\n"
    "    OvernightIndexFuture::OvernightIndexFuture(ext::shared_ptr< OvernightIndex >,Date const &,Date const &,Handle< Quote >)\n"
    "    OvernightIndexFuture::OvernightIndexFuture(ext::shared_ptr< OvernightIndex >,Date const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_OvernightIndexFuture_convexityAdjustment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexFuture *arg1 = (OvernightIndexFuture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexFuture const > tempshared1 ;
  ext::shared_ptr< OvernightIndexFuture const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OvernightIndexFuture_convexityAdjustment" "', argument " "1"" of type '" "OvernightIndexFuture const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OvernightIndexFuture > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OvernightIndexFuture > * >(argp1);
      arg1 = const_cast< OvernightIndexFuture * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OvernightIndexFuture > * >(argp1);
      arg1 = const_cast< OvernightIndexFuture * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((OvernightIndexFuture const *)arg1)->convexityAdjustment();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIndexFuture(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexFuture *arg1 = (OvernightIndexFuture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexFuture > tempshared1 ;
  ext::shared_ptr< OvernightIndexFuture > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndexFuture" "', argument " "1"" of type '" "OvernightIndexFuture *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexFuture > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexFuture > * >(argp1);
      arg1 = const_cast< OvernightIndexFuture * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexFuture > * >(argp1);
      arg1 = const_cast< OvernightIndexFuture * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIndexFuture_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFuture_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIndexFuture_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Pillar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Pillar *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Pillar", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Pillar *)new Pillar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pillar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Pillar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Pillar *arg1 = (Pillar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Pillar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pillar" "', argument " "1"" of type '" "Pillar *""'"); 
  }
  arg1 = reinterpret_cast< Pillar * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Pillar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pillar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Pillar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RateHelper_quote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_quote" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Handle< Quote > *) &((RateHelper const *)arg1)->quote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_Quote_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_latestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_latestDate" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((RateHelper const *)arg1)->latestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_earliestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_earliestDate" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((RateHelper const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_maturityDate" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((RateHelper const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_latestRelevantDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_latestRelevantDate" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((RateHelper const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_pillarDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_pillarDate" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((RateHelper const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_impliedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_impliedQuote" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((RateHelper const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelper_quoteError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper const > tempshared1 ;
  ext::shared_ptr< RateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelper_quoteError" "', argument " "1"" of type '" "RateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((RateHelper const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RateHelper *arg1 = (RateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RateHelper > tempshared1 ;
  ext::shared_ptr< RateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RateHelper" "', argument " "1"" of type '" "RateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  RateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  RateHelper > * >(argp1);
      arg1 = const_cast< RateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DepositRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  DepositRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DepositRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DepositRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DepositRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DepositRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DepositRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DepositRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DepositRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DepositRateHelper > *smartresult = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DepositRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  DepositRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DepositRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DepositRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DepositRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DepositRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DepositRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DepositRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DepositRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DepositRateHelper > *smartresult = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DepositRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< IborIndex > tempshared2 ;
  DepositRateHelper *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DepositRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DepositRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DepositRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< IborIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DepositRateHelper > *smartresult = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DepositRateHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< IborIndex > tempshared2 ;
  DepositRateHelper *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DepositRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DepositRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (DepositRateHelper *)new DepositRateHelper(arg1,(ext::shared_ptr< IborIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DepositRateHelper > *smartresult = result ? new ext::shared_ptr<  DepositRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DepositRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DepositRateHelper", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DepositRateHelper__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DepositRateHelper__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_DepositRateHelper__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_DepositRateHelper__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DepositRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DepositRateHelper::DepositRateHelper(Handle< Quote > const &,Period const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n"
    "    DepositRateHelper::DepositRateHelper(Rate,Period const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n"
    "    DepositRateHelper::DepositRateHelper(Handle< Quote > const &,ext::shared_ptr< IborIndex > const &)\n"
    "    DepositRateHelper::DepositRateHelper(Rate,ext::shared_ptr< IborIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DepositRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DepositRateHelper *arg1 = (DepositRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DepositRateHelper > tempshared1 ;
  ext::shared_ptr< DepositRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DepositRateHelper" "', argument " "1"" of type '" "DepositRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DepositRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DepositRateHelper > * >(argp1);
      arg1 = const_cast< DepositRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DepositRateHelper > * >(argp1);
      arg1 = const_cast< DepositRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DepositRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DepositRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FraRateHelper" "', argument " "9"" of type '" "Pillar::Choice""'");
  } 
  arg9 = static_cast< Pillar::Choice >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FraRateHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FraRateHelper" "', argument " "9"" of type '" "Pillar::Choice""'");
  } 
  arg9 = static_cast< Pillar::Choice >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FraRateHelper" "', argument " "9"" of type '" "Pillar::Choice""'");
  } 
  arg9 = static_cast< Pillar::Choice >(val9);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  bool arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FraRateHelper" "', argument " "9"" of type '" "Pillar::Choice""'");
  } 
  arg9 = static_cast< Pillar::Choice >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FraRateHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  Date arg10 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FraRateHelper" "', argument " "9"" of type '" "Pillar::Choice""'");
  } 
  arg9 = static_cast< Pillar::Choice >(val9);
  {
    res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "10"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  Pillar::Choice arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FraRateHelper" "', argument " "9"" of type '" "Pillar::Choice""'");
  } 
  arg9 = static_cast< Pillar::Choice >(val9);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  DayCounter *arg8 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,arg4,(Calendar const &)*arg5,arg6,arg7,(DayCounter const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Pillar::Choice""'");
  } 
  arg5 = static_cast< Pillar::Choice >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Pillar::Choice""'");
  } 
  arg5 = static_cast< Pillar::Choice >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  int val5 ;
  int ecode5 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Pillar::Choice""'");
  } 
  arg5 = static_cast< Pillar::Choice >(val5);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  bool arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Pillar::Choice""'");
  } 
  arg5 = static_cast< Pillar::Choice >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FraRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  Date arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Pillar::Choice""'");
  } 
  arg5 = static_cast< Pillar::Choice >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_22(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  Pillar::Choice arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  int val5 ;
  int ecode5 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Pillar::Choice""'");
  } 
  arg5 = static_cast< Pillar::Choice >(val5);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_23(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Natural arg2 ;
  Natural arg3 ;
  ext::shared_ptr< IborIndex > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< IborIndex > tempshared4 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Natural""'");
  } 
  arg2 = static_cast< Natural >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,arg3,(ext::shared_ptr< IborIndex > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_24(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_25(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_26(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_27(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper(arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_28(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FraRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_29(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  Date arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "5"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_30(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Pillar::Choice arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  int val4 ;
  int ecode4 = 0 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FraRateHelper" "', argument " "4"" of type '" "Pillar::Choice""'");
  } 
  arg4 = static_cast< Pillar::Choice >(val4);
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper__SWIG_31(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period arg2 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  FraRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FraRateHelper" "', argument " "2"" of type '" "Period""'");
    } else {
      Period * temp = reinterpret_cast< Period * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FraRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FraRateHelper *)new FraRateHelper((Handle< Quote > const &)*arg1,arg2,(ext::shared_ptr< IborIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FraRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FraRateHelper", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FraRateHelper__SWIG_31(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FraRateHelper__SWIG_11(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FraRateHelper__SWIG_27(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FraRateHelper__SWIG_15(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FraRateHelper__SWIG_30(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FraRateHelper__SWIG_10(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FraRateHelper__SWIG_19(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FraRateHelper__SWIG_26(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FraRateHelper__SWIG_14(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FraRateHelper__SWIG_23(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FraRateHelper__SWIG_29(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FraRateHelper__SWIG_9(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FraRateHelper__SWIG_18(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FraRateHelper__SWIG_25(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FraRateHelper__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FraRateHelper__SWIG_22(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FraRateHelper__SWIG_28(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FraRateHelper__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FraRateHelper__SWIG_17(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FraRateHelper__SWIG_24(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FraRateHelper__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FraRateHelper__SWIG_21(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FraRateHelper__SWIG_16(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FraRateHelper__SWIG_20(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FraRateHelper__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FraRateHelper__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FraRateHelper__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FraRateHelper__SWIG_6(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FraRateHelper__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FraRateHelper__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_FraRateHelper__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_FraRateHelper__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FraRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,ext::shared_ptr< IborIndex > const &)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,ext::shared_ptr< IborIndex > const &)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Natural,Natural,ext::shared_ptr< IborIndex > const &)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,ext::shared_ptr< IborIndex > const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Rate,Natural,Natural,ext::shared_ptr< IborIndex > const &)\n"
    "    FraRateHelper::FraRateHelper(Rate,Period,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Rate,Period,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Rate,Period,ext::shared_ptr< IborIndex > const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Rate,Period,ext::shared_ptr< IborIndex > const &)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Period,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date,bool)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Period,ext::shared_ptr< IborIndex > const &,Pillar::Choice,Date)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Period,ext::shared_ptr< IborIndex > const &,Pillar::Choice)\n"
    "    FraRateHelper::FraRateHelper(Handle< Quote > const &,Period,ext::shared_ptr< IborIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FraRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FraRateHelper *arg1 = (FraRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FraRateHelper > tempshared1 ;
  ext::shared_ptr< FraRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FraRateHelper" "', argument " "1"" of type '" "FraRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FraRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FraRateHelper > * >(argp1);
      arg1 = const_cast< FraRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FraRateHelper > * >(argp1);
      arg1 = const_cast< FraRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FraRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FraRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Futures::Type arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FuturesRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FuturesRateHelper" "', argument " "9"" of type '" "Futures::Type""'");
  } 
  arg9 = static_cast< Futures::Type >(val9);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,(Handle< Quote > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FuturesRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,(Handle< Quote > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  Futures::Type arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FuturesRateHelper" "', argument " "8"" of type '" "Rate""'");
  } 
  arg8 = static_cast< Rate >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FuturesRateHelper" "', argument " "9"" of type '" "Futures::Type""'");
  } 
  arg9 = static_cast< Futures::Type >(val9);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  Rate arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FuturesRateHelper" "', argument " "8"" of type '" "Rate""'");
  } 
  arg8 = static_cast< Rate >(val8);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Natural arg3 ;
  Calendar *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  DayCounter *arg7 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  Futures::Type arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "Futures::Type""'");
  } 
  arg6 = static_cast< Futures::Type >(val6);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,(Handle< Quote > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,(Handle< Quote > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Rate arg5 ;
  Futures::Type arg6 ;
  double 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 ;
  int val6 ;
  int ecode6 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FuturesRateHelper" "', argument " "6"" of type '" "Futures::Type""'");
  } 
  arg6 = static_cast< Futures::Type >(val6);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Rate arg5 ;
  double 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 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Futures::Type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Futures::Type""'");
  } 
  arg5 = static_cast< Futures::Type >(val5);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(Handle< Quote > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Real arg4 ;
  Futures::Type arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FuturesRateHelper" "', argument " "5"" of type '" "Futures::Type""'");
  } 
  arg5 = static_cast< Futures::Type >(val5);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FuturesRateHelper" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Date *arg2 = 0 ;
  ext::shared_ptr< IborIndex > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< IborIndex > tempshared3 ;
  FuturesRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FuturesRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FuturesRateHelper" "', argument " "3"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FuturesRateHelper *)new FuturesRateHelper(arg1,(Date const &)*arg2,(ext::shared_ptr< IborIndex > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FuturesRateHelper > *smartresult = result ? new ext::shared_ptr<  FuturesRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FuturesRateHelper", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FuturesRateHelper__SWIG_14(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FuturesRateHelper__SWIG_17(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FuturesRateHelper__SWIG_13(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FuturesRateHelper__SWIG_8(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FuturesRateHelper__SWIG_16(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FuturesRateHelper__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FuturesRateHelper__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FuturesRateHelper__SWIG_12(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FuturesRateHelper__SWIG_15(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FuturesRateHelper__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FuturesRateHelper__SWIG_6(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FuturesRateHelper__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FuturesRateHelper__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FuturesRateHelper__SWIG_5(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_FuturesRateHelper__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FuturesRateHelper__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FuturesRateHelper__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FuturesRateHelper__SWIG_3(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FuturesRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Handle< Quote > const &,Futures::Type)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Handle< Quote > const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Rate,Futures::Type)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &,Rate)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,Natural,Calendar const &,BusinessDayConvention,bool,DayCounter const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,Date const &,DayCounter const &,Handle< Quote > const &,Futures::Type)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,Date const &,DayCounter const &,Handle< Quote > const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,Date const &,DayCounter const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,Date const &,DayCounter const &,Rate,Futures::Type)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,Date const &,DayCounter const &,Rate)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,Date const &,DayCounter const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Futures::Type)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Handle< Quote > const &,Date const &,ext::shared_ptr< IborIndex > const &)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,ext::shared_ptr< IborIndex > const &,Real,Futures::Type)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,ext::shared_ptr< IborIndex > const &,Real)\n"
    "    FuturesRateHelper::FuturesRateHelper(Real,Date const &,ext::shared_ptr< IborIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FuturesRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FuturesRateHelper *arg1 = (FuturesRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FuturesRateHelper > tempshared1 ;
  ext::shared_ptr< FuturesRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FuturesRateHelper" "', argument " "1"" of type '" "FuturesRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FuturesRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FuturesRateHelper > * >(argp1);
      arg1 = const_cast< FuturesRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FuturesRateHelper > * >(argp1);
      arg1 = const_cast< FuturesRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FuturesRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FuturesRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FuturesRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  ext::optional< bool > arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SwapRateHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  
  if(swig_obj[14] == Py_None)
  arg15 = ext::nullopt;
  else if (swig_obj[14] == Py_True)
  arg15 = true;
  else
  arg15 = false;
  
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SwapRateHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  ext::optional< bool > arg15 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SwapRateHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  
  if(swig_obj[14] == Py_None)
  arg15 = ext::nullopt;
  else if (swig_obj[14] == Py_True)
  arg15 = true;
  else
  arg15 = false;
  
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  bool arg14 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_SwapRateHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  Date arg13 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'"); 
    }  
    if (!argp13) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "13"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp13);
      arg13 = *temp;
      if (SWIG_IsNewObj(res13)) delete temp;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  Pillar::Choice arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SwapRateHelper" "', argument " "12"" of type '" "Pillar::Choice""'");
  } 
  arg12 = static_cast< Pillar::Choice >(val12);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  Natural arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  unsigned int val11 ;
  int ecode11 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_unsigned_SS_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SwapRateHelper" "', argument " "11"" of type '" "Natural""'");
  } 
  arg11 = static_cast< Natural >(val11);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  Period *arg9 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "9"" of type '" "Period const &""'"); 
  }
  arg9 = reinterpret_cast< Period * >(argp9);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8,(Period const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  Handle< Quote > *arg8 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "Handle< Quote > const &""'"); 
  }
  arg8 = reinterpret_cast< Handle< Quote > * >(argp8);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(Handle< Quote > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Calendar *arg3 = 0 ;
  Frequency arg4 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Calendar const &""'"); 
  }
  arg3 = reinterpret_cast< Calendar * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(Period const &)*arg2,(Calendar const &)*arg3,arg4,arg5,(DayCounter const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  ext::optional< bool > arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  
  if(swig_obj[8] == Py_None)
  arg9 = ext::nullopt;
  else if (swig_obj[8] == Py_True)
  arg9 = true;
  else
  arg9 = false;
  
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_19(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_20(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_21(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_22(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_23(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_24(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_25(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_26(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  ext::optional< bool > arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  
  if(swig_obj[8] == Py_None)
  arg9 = ext::nullopt;
  else if (swig_obj[8] == Py_True)
  arg9 = true;
  else
  arg9 = false;
  
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_27(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  bool arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SwapRateHelper" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_28(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  Date arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "7"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_29(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  Pillar::Choice arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SwapRateHelper" "', argument " "6"" of type '" "Pillar::Choice""'");
  } 
  arg6 = static_cast< Pillar::Choice >(val6);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_30(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_31(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  Period *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "4"" of type '" "Period const &""'"); 
  }
  arg4 = reinterpret_cast< Period * >(argp4);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3,(Period const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_32(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper__SWIG_33(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  ext::shared_ptr< SwapIndex > *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared2 ;
  SwapRateHelper *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SwapRateHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SwapRateHelper" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (SwapRateHelper *)new SwapRateHelper(arg1,(ext::shared_ptr< SwapIndex > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SwapRateHelper", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SwapRateHelper__SWIG_25(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SwapRateHelper__SWIG_33(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SwapRateHelper__SWIG_24(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SwapRateHelper__SWIG_32(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SwapRateHelper__SWIG_23(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SwapRateHelper__SWIG_31(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SwapRateHelper__SWIG_22(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SwapRateHelper__SWIG_30(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SwapRateHelper__SWIG_21(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SwapRateHelper__SWIG_29(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SwapRateHelper__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SwapRateHelper__SWIG_20(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SwapRateHelper__SWIG_28(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SwapRateHelper__SWIG_17(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SwapRateHelper__SWIG_19(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_SwapRateHelper__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_SwapRateHelper__SWIG_16(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SwapRateHelper__SWIG_27(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      if (PyBool_Check(argv[8]) || Py_None == argv[8]) 
                      _v = 1;
                      else
                      _v = 0;
                    }
                    if (_v) {
                      return _wrap_new_SwapRateHelper__SWIG_18(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_SwapRateHelper__SWIG_6(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      if (PyBool_Check(argv[8]) || Py_None == argv[8]) 
                      _v = 1;
                      else
                      _v = 0;
                    }
                    if (_v) {
                      return _wrap_new_SwapRateHelper__SWIG_26(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_SwapRateHelper__SWIG_15(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_SwapRateHelper__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_SwapRateHelper__SWIG_14(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SwapRateHelper__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SwapRateHelper__SWIG_13(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SwapRateHelper__SWIG_3(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SwapRateHelper__SWIG_12(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_SwapRateHelper__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_SwapRateHelper__SWIG_11(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_SwapRateHelper__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_SwapRateHelper__SWIG_10(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  if (PyBool_Check(argv[14]) || Py_None == argv[14]) 
                                  _v = 1;
                                  else
                                  _v = 0;
                                }
                                if (_v) {
                                  return _wrap_new_SwapRateHelper__SWIG_0(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  if (PyBool_Check(argv[14]) || Py_None == argv[14]) 
                                  _v = 1;
                                  else
                                  _v = 0;
                                }
                                if (_v) {
                                  return _wrap_new_SwapRateHelper__SWIG_9(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SwapRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice,Date,bool,ext::optional< bool >)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice,Date,bool)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice,Date)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice,Date,bool,ext::optional< bool >)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice,Date,bool)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice,Date)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural,Pillar::Choice)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Natural)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &,Period const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &,Handle< Quote > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,Period const &,Calendar const &,Frequency,BusinessDayConvention,DayCounter const &,ext::shared_ptr< IborIndex > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice,Date,bool,ext::optional< bool >)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice,Date,bool)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice,Date)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Handle< Quote > const &,ext::shared_ptr< SwapIndex > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice,Date,bool,ext::optional< bool >)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice,Date,bool)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice,Date)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &,Pillar::Choice)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &,Handle< YieldTermStructure > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &,Period const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &,Handle< Quote > const &)\n"
    "    SwapRateHelper::SwapRateHelper(Rate,ext::shared_ptr< SwapIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwapRateHelper_spread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapRateHelper *arg1 = (SwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapRateHelper > tempshared1 ;
  ext::shared_ptr< SwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Spread result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapRateHelper_spread" "', argument " "1"" of type '" "SwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      arg1 = const_cast< SwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      arg1 = const_cast< SwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Spread)(arg1)->spread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwapRateHelper_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapRateHelper *arg1 = (SwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapRateHelper > tempshared1 ;
  ext::shared_ptr< SwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< VanillaSwap > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwapRateHelper_swap" "', argument " "1"" of type '" "SwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      arg1 = const_cast< SwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      arg1 = const_cast< SwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->swap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwap > *smartresult = result ? new ext::shared_ptr<  VanillaSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwapRateHelper *arg1 = (SwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SwapRateHelper > tempshared1 ;
  ext::shared_ptr< SwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwapRateHelper" "', argument " "1"" of type '" "SwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      arg1 = const_cast< SwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SwapRateHelper > * >(argp1);
      arg1 = const_cast< SwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwapRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SwapRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BondHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  BondPrice::Type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  BondHelper *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BondHelper" "', argument " "2"" of type '" "ext::shared_ptr< Bond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Bond > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Bond > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BondHelper" "', argument " "3"" of type '" "BondPrice::Type""'");
  } 
  arg3 = static_cast< BondPrice::Type >(val3);
  {
    try {
      result = (BondHelper *)new BondHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< Bond > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondHelper > *smartresult = result ? new ext::shared_ptr<  BondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  ext::shared_ptr< Bond > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Bond > tempshared2 ;
  BondHelper *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BondHelper" "', argument " "2"" of type '" "ext::shared_ptr< Bond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Bond > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Bond > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Bond > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (BondHelper *)new BondHelper((Handle< Quote > const &)*arg1,(ext::shared_ptr< Bond > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondHelper > *smartresult = result ? new ext::shared_ptr<  BondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BondHelper", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BondHelper__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Bond_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BondHelper__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BondHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BondHelper::BondHelper(Handle< Quote > const &,ext::shared_ptr< Bond > const &,BondPrice::Type)\n"
    "    BondHelper::BondHelper(Handle< Quote > const &,ext::shared_ptr< Bond > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelper_bond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondHelper *arg1 = (BondHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BondHelper > tempshared1 ;
  ext::shared_ptr< BondHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Bond > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelper_bond" "', argument " "1"" of type '" "BondHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BondHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BondHelper > * >(argp1);
      arg1 = const_cast< BondHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BondHelper > * >(argp1);
      arg1 = const_cast< BondHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->bond();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Bond > *smartresult = result ? new ext::shared_ptr<  Bond >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Bond_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BondHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BondHelper *arg1 = (BondHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BondHelper > tempshared1 ;
  ext::shared_ptr< BondHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BondHelper" "', argument " "1"" of type '" "BondHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BondHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BondHelper > * >(argp1);
      arg1 = const_cast< BondHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BondHelper > * >(argp1);
      arg1 = const_cast< BondHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BondHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BondHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  bool arg14 ;
  BondPrice::Type arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 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 ;
  int val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  arg11 = reinterpret_cast< Period * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_FixedRateBondHelper" "', argument " "13"" of type '" "BusinessDayConvention""'");
  } 
  arg13 = static_cast< BusinessDayConvention >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBondHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FixedRateBondHelper" "', argument " "15"" of type '" "BondPrice::Type""'");
  } 
  arg15 = static_cast< BondPrice::Type >(val15);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13,arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 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 ;
  int val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  arg11 = reinterpret_cast< Period * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_FixedRateBondHelper" "', argument " "13"" of type '" "BusinessDayConvention""'");
  } 
  arg13 = static_cast< BusinessDayConvention >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FixedRateBondHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  BusinessDayConvention arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 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 ;
  int val13 ;
  int ecode13 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  arg11 = reinterpret_cast< Period * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_FixedRateBondHelper" "', argument " "13"" of type '" "BusinessDayConvention""'");
  } 
  arg13 = static_cast< BusinessDayConvention >(val13);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  Calendar *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 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 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  arg11 = reinterpret_cast< Period * >(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[11], &argp12, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "12"" of type '" "Calendar const &""'"); 
  }
  arg12 = reinterpret_cast< Calendar * >(argp12);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11,(Calendar const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  Period *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "11"" of type '" "Period const &""'"); 
  }
  arg11 = reinterpret_cast< Period * >(argp11);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10,(Period const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(Calendar const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  Date *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FixedRateBondHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  BusinessDayConvention arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedRateBondHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Size arg2 ;
  Real arg3 ;
  Schedule *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  FixedRateBondHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedRateBondHelper" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FixedRateBondHelper" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedRateBondHelper" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (FixedRateBondHelper *)new FixedRateBondHelper((Handle< Quote > const &)*arg1,arg2,arg3,(Schedule const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBondHelper > *smartresult = result ? new ext::shared_ptr<  FixedRateBondHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedRateBondHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FixedRateBondHelper", 0, 15, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FixedRateBondHelper__SWIG_9(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FixedRateBondHelper__SWIG_8(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FixedRateBondHelper__SWIG_7(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_FixedRateBondHelper__SWIG_6(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FixedRateBondHelper__SWIG_5(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_FixedRateBondHelper__SWIG_4(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_FixedRateBondHelper__SWIG_3(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_FixedRateBondHelper__SWIG_2(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_FixedRateBondHelper__SWIG_1(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_FixedRateBondHelper__SWIG_0(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FixedRateBondHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &,BusinessDayConvention,bool,BondPrice::Type)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &,BusinessDayConvention,bool)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &,BusinessDayConvention)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &,Calendar const &)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &,Calendar const &,Period const &)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &,Calendar const &)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real,Date const &)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention,Real)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,BusinessDayConvention)\n"
    "    FixedRateBondHelper::FixedRateBondHelper(Handle< Quote > const &,Size,Real,Schedule const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FixedRateBondHelper_fixedRateBond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateBondHelper *arg1 = (FixedRateBondHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateBondHelper > tempshared1 ;
  ext::shared_ptr< FixedRateBondHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FixedRateBond > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRateBondHelper_fixedRateBond" "', argument " "1"" of type '" "FixedRateBondHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedRateBondHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedRateBondHelper > * >(argp1);
      arg1 = const_cast< FixedRateBondHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedRateBondHelper > * >(argp1);
      arg1 = const_cast< FixedRateBondHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->fixedRateBond();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedRateBond > *smartresult = result ? new ext::shared_ptr<  FixedRateBond >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedRateBond_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FixedRateBondHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedRateBondHelper *arg1 = (FixedRateBondHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedRateBondHelper > tempshared1 ;
  ext::shared_ptr< FixedRateBondHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedRateBondHelper" "', argument " "1"" of type '" "FixedRateBondHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedRateBondHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedRateBondHelper > * >(argp1);
      arg1 = const_cast< FixedRateBondHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedRateBondHelper > * >(argp1);
      arg1 = const_cast< FixedRateBondHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedRateBondHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FixedRateBondHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedRateBondHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OISRateHelper(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > const &arg5_defvalue = {
    
  } ;
  Handle< YieldTermStructure > *arg5 = (Handle< YieldTermStructure > *) &arg5_defvalue ;
  bool arg6 = (bool) false ;
  Integer arg7 = (Integer) 0 ;
  BusinessDayConvention arg8 = (BusinessDayConvention) Following ;
  Frequency arg9 = (Frequency) Annual ;
  Calendar const &arg10_defvalue = Calendar() ;
  Calendar *arg10 = (Calendar *) &arg10_defvalue ;
  Period const &arg11_defvalue = 0*Days ;
  Period *arg11 = (Period *) &arg11_defvalue ;
  Spread arg12 = (Spread) (Spread)0.0 ;
  Pillar::Choice arg13 = (Pillar::Choice) Pillar::LastRelevantDate ;
  Date arg14 = (Date) Date() ;
  RateAveraging::Type arg15 = (RateAveraging::Type) RateAveraging::Compound ;
  ext::optional< bool > arg16 = (ext::optional< bool >) ext::nullopt ;
  ext::optional< Frequency > arg17 = (ext::optional< Frequency >) ext::nullopt ;
  Calendar const &arg18_defvalue = Calendar() ;
  Calendar *arg18 = (Calendar *) &arg18_defvalue ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  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 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"tenor",  (char *)"rate",  (char *)"index",  (char *)"discountingCurve",  (char *)"telescopicValueDates",  (char *)"paymentLag",  (char *)"paymentConvention",  (char *)"paymentFrequency",  (char *)"paymentCalendar",  (char *)"forwardStart",  (char *)"overnightSpread",  (char *)"pillar",  (char *)"customPillarDate",  (char *)"averagingMethod",  (char *)"endOfMonth",  (char *)"fixedPaymentFrequency",  (char *)"fixedCalendar",  NULL 
  };
  OISRateHelper *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOOOOOOOOOO:new_OISRateHelper", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OISRateHelper" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OISRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OISRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4) : &tempshared4;
    }
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OISRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
    }
    arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_bool(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OISRateHelper" "', argument " "6"" of type '" "bool""'");
    } 
    arg6 = static_cast< bool >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OISRateHelper" "', argument " "7"" of type '" "Integer""'");
    } 
    arg7 = static_cast< Integer >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OISRateHelper" "', argument " "8"" of type '" "BusinessDayConvention""'");
    } 
    arg8 = static_cast< BusinessDayConvention >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OISRateHelper" "', argument " "9"" of type '" "Frequency""'");
    } 
    arg9 = static_cast< Frequency >(val9);
  }
  if (obj9) {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_OISRateHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
    }
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
    }
    arg10 = reinterpret_cast< Calendar * >(argp10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_OISRateHelper" "', argument " "11"" of type '" "Period const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "11"" of type '" "Period const &""'"); 
    }
    arg11 = reinterpret_cast< Period * >(argp11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_double(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_OISRateHelper" "', argument " "12"" of type '" "Spread""'");
    } 
    arg12 = static_cast< Spread >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_int(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_OISRateHelper" "', argument " "13"" of type '" "Pillar::Choice""'");
    } 
    arg13 = static_cast< Pillar::Choice >(val13);
  }
  if (obj13) {
    {
      res14 = SWIG_ConvertPtr(obj13, &argp14, SWIGTYPE_p_Date,  0  | 0);
      if (!SWIG_IsOK(res14)) {
        SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_OISRateHelper" "', argument " "14"" of type '" "Date""'"); 
      }  
      if (!argp14) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "14"" of type '" "Date""'");
      } else {
        Date * temp = reinterpret_cast< Date * >(argp14);
        arg14 = *temp;
        if (SWIG_IsNewObj(res14)) delete temp;
      }
    }
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_int(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_OISRateHelper" "', argument " "15"" of type '" "RateAveraging::Type""'");
    } 
    arg15 = static_cast< RateAveraging::Type >(val15);
  }
  if (obj15) {
    if(obj15 == Py_None)
    arg16 = ext::nullopt;
    else if (obj15 == Py_True)
    arg16 = true;
    else
    arg16 = false;
    
  }
  if (obj16) {
    if(obj16 == Py_None)
    arg17 = ext::nullopt;
    else if (PyInt_Check(obj16))
    arg17 = (Frequency) PyInt_AsLong(obj16);
    else
    arg17 = (Frequency) PyLong_AsLong(obj16);
    
  }
  if (obj17) {
    res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res18)) {
      SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "new_OISRateHelper" "', argument " "18"" of type '" "Calendar const &""'"); 
    }
    if (!argp18) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OISRateHelper" "', argument " "18"" of type '" "Calendar const &""'"); 
    }
    arg18 = reinterpret_cast< Calendar * >(argp18);
  }
  {
    try {
      result = (OISRateHelper *)new OISRateHelper(arg1,(Period const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,(Calendar const &)*arg10,(Period const &)*arg11,arg12,arg13,arg14,arg15,arg16,arg17,(Calendar const &)*arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OISRateHelper > *smartresult = result ? new ext::shared_ptr<  OISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OISRateHelper_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OISRateHelper *arg1 = (OISRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OISRateHelper > tempshared1 ;
  ext::shared_ptr< OISRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OvernightIndexedSwap > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OISRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OISRateHelper_swap" "', argument " "1"" of type '" "OISRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OISRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OISRateHelper > * >(argp1);
      arg1 = const_cast< OISRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OISRateHelper > * >(argp1);
      arg1 = const_cast< OISRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->swap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexedSwap > *smartresult = result ? new ext::shared_ptr<  OvernightIndexedSwap >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexedSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OISRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OISRateHelper *arg1 = (OISRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OISRateHelper > tempshared1 ;
  ext::shared_ptr< OISRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OISRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OISRateHelper" "', argument " "1"" of type '" "OISRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OISRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OISRateHelper > * >(argp1);
      arg1 = const_cast< OISRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OISRateHelper > * >(argp1);
      arg1 = const_cast< OISRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OISRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OISRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OISRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DatedOISRateHelper(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< YieldTermStructure > const &arg5_defvalue = {
    
  } ;
  Handle< YieldTermStructure > *arg5 = (Handle< YieldTermStructure > *) &arg5_defvalue ;
  bool arg6 = (bool) false ;
  RateAveraging::Type arg7 = (RateAveraging::Type) RateAveraging::Compound ;
  Integer arg8 = (Integer) 0 ;
  BusinessDayConvention arg9 = (BusinessDayConvention) Following ;
  Frequency arg10 = (Frequency) Annual ;
  Calendar const &arg11_defvalue = Calendar() ;
  Calendar *arg11 = (Calendar *) &arg11_defvalue ;
  Period const &arg12_defvalue = 0*Days ;
  Period *arg12 = (Period *) &arg12_defvalue ;
  Spread arg13 = (Spread) 0.0 ;
  ext::optional< bool > arg14 = (ext::optional< bool >) ext::nullopt ;
  ext::optional< Frequency > arg15 = (ext::optional< Frequency >) ext::nullopt ;
  Calendar const &arg16_defvalue = Calendar() ;
  Calendar *arg16 = (Calendar *) &arg16_defvalue ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  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 ;
  char * kwnames[] = {
    (char *)"startDate",  (char *)"endDate",  (char *)"rate",  (char *)"index",  (char *)"discountingCurve",  (char *)"telescopicValueDates",  (char *)"averagingMethod",  (char *)"paymentLag",  (char *)"paymentConvention",  (char *)"paymentFrequency",  (char *)"paymentCalendar",  (char *)"forwardStart",  (char *)"overnightSpread",  (char *)"endOfMonth",  (char *)"fixedPaymentFrequency",  (char *)"fixedCalendar",  NULL 
  };
  DatedOISRateHelper *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOOOOOOOO:new_DatedOISRateHelper", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatedOISRateHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DatedOISRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DatedOISRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DatedOISRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4) : &tempshared4;
    }
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DatedOISRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
    }
    arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_bool(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DatedOISRateHelper" "', argument " "6"" of type '" "bool""'");
    } 
    arg6 = static_cast< bool >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DatedOISRateHelper" "', argument " "7"" of type '" "RateAveraging::Type""'");
    } 
    arg7 = static_cast< RateAveraging::Type >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DatedOISRateHelper" "', argument " "8"" of type '" "Integer""'");
    } 
    arg8 = static_cast< Integer >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DatedOISRateHelper" "', argument " "9"" of type '" "BusinessDayConvention""'");
    } 
    arg9 = static_cast< BusinessDayConvention >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_int(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_DatedOISRateHelper" "', argument " "10"" of type '" "Frequency""'");
    } 
    arg10 = static_cast< Frequency >(val10);
  }
  if (obj10) {
    res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_DatedOISRateHelper" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "11"" of type '" "Calendar const &""'"); 
    }
    arg11 = reinterpret_cast< Calendar * >(argp11);
  }
  if (obj11) {
    res12 = SWIG_ConvertPtr(obj11, &argp12, SWIGTYPE_p_Period,  0  | 0);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_DatedOISRateHelper" "', argument " "12"" of type '" "Period const &""'"); 
    }
    if (!argp12) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "12"" of type '" "Period const &""'"); 
    }
    arg12 = reinterpret_cast< Period * >(argp12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_double(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_DatedOISRateHelper" "', argument " "13"" of type '" "Spread""'");
    } 
    arg13 = static_cast< Spread >(val13);
  }
  if (obj13) {
    if(obj13 == Py_None)
    arg14 = ext::nullopt;
    else if (obj13 == Py_True)
    arg14 = true;
    else
    arg14 = false;
    
  }
  if (obj14) {
    if(obj14 == Py_None)
    arg15 = ext::nullopt;
    else if (PyInt_Check(obj14))
    arg15 = (Frequency) PyInt_AsLong(obj14);
    else
    arg15 = (Frequency) PyLong_AsLong(obj14);
    
  }
  if (obj15) {
    res16 = SWIG_ConvertPtr(obj15, &argp16, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res16)) {
      SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DatedOISRateHelper" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    if (!argp16) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedOISRateHelper" "', argument " "16"" of type '" "Calendar const &""'"); 
    }
    arg16 = reinterpret_cast< Calendar * >(argp16);
  }
  {
    try {
      result = (DatedOISRateHelper *)new DatedOISRateHelper((Date const &)*arg1,(Date const &)*arg2,(Handle< Quote > const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< YieldTermStructure > const &)*arg5,arg6,arg7,arg8,arg9,arg10,(Calendar const &)*arg11,(Period const &)*arg12,arg13,arg14,arg15,(Calendar const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DatedOISRateHelper > *smartresult = result ? new ext::shared_ptr<  DatedOISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DatedOISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DatedOISRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DatedOISRateHelper *arg1 = (DatedOISRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DatedOISRateHelper > tempshared1 ;
  ext::shared_ptr< DatedOISRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DatedOISRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatedOISRateHelper" "', argument " "1"" of type '" "DatedOISRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DatedOISRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DatedOISRateHelper > * >(argp1);
      arg1 = const_cast< DatedOISRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DatedOISRateHelper > * >(argp1);
      arg1 = const_cast< DatedOISRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DatedOISRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DatedOISRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DatedOISRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FxSwapRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Period *arg3 = 0 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  bool arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Calendar *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  FxSwapRateHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FxSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FxSwapRateHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FxSwapRateHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FxSwapRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FxSwapRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FxSwapRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FxSwapRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FxSwapRateHelper" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FxSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FxSwapRateHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "10"" of type '" "Calendar const &""'"); 
  }
  arg10 = reinterpret_cast< Calendar * >(argp10);
  {
    try {
      result = (FxSwapRateHelper *)new FxSwapRateHelper((Handle< Quote > const &)*arg1,(Handle< Quote > const &)*arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,(Calendar const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FxSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  FxSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FxSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FxSwapRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  Period *arg3 = 0 ;
  Natural arg4 ;
  Calendar *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  bool arg7 ;
  bool arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  FxSwapRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FxSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FxSwapRateHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FxSwapRateHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FxSwapRateHelper" "', argument " "4"" of type '" "Natural""'");
  } 
  arg4 = static_cast< Natural >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FxSwapRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FxSwapRateHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FxSwapRateHelper" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FxSwapRateHelper" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FxSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FxSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  {
    try {
      result = (FxSwapRateHelper *)new FxSwapRateHelper((Handle< Quote > const &)*arg1,(Handle< Quote > const &)*arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FxSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  FxSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FxSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FxSwapRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FxSwapRateHelper", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_FxSwapRateHelper__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_FxSwapRateHelper__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FxSwapRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FxSwapRateHelper::FxSwapRateHelper(Handle< Quote > const &,Handle< Quote > const &,Period const &,Natural,Calendar const &,BusinessDayConvention,bool,bool,Handle< YieldTermStructure > const &,Calendar const &)\n"
    "    FxSwapRateHelper::FxSwapRateHelper(Handle< Quote > const &,Handle< Quote > const &,Period const &,Natural,Calendar const &,BusinessDayConvention,bool,bool,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FxSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FxSwapRateHelper *arg1 = (FxSwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FxSwapRateHelper > tempshared1 ;
  ext::shared_ptr< FxSwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FxSwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FxSwapRateHelper" "', argument " "1"" of type '" "FxSwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FxSwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FxSwapRateHelper > * >(argp1);
      arg1 = const_cast< FxSwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FxSwapRateHelper > * >(argp1);
      arg1 = const_cast< FxSwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FxSwapRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FxSwapRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FxSwapRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OvernightIndexFutureRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  RateAveraging::Type arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  OvernightIndexFutureRateHelper *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "6"" of type '" "RateAveraging::Type""'");
  } 
  arg6 = static_cast< RateAveraging::Type >(val6);
  {
    try {
      result = (OvernightIndexFutureRateHelper *)new OvernightIndexFutureRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< Quote > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  OvernightIndexFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexFutureRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  Handle< Quote > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  OvernightIndexFutureRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    try {
      result = (OvernightIndexFutureRateHelper *)new OvernightIndexFutureRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4,(Handle< Quote > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  OvernightIndexFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexFutureRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  ext::shared_ptr< OvernightIndex > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared4 ;
  OvernightIndexFutureRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIndexFutureRateHelper" "', argument " "4"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (OvernightIndexFutureRateHelper *)new OvernightIndexFutureRateHelper((Handle< Quote > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,(ext::shared_ptr< OvernightIndex > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIndexFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  OvernightIndexFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIndexFutureRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIndexFutureRateHelper", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_OvernightIndexFutureRateHelper__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_OvernightIndexFutureRateHelper__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_OvernightIndexFutureRateHelper__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIndexFutureRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIndexFutureRateHelper::OvernightIndexFutureRateHelper(Handle< Quote > const &,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Handle< Quote > const &,RateAveraging::Type)\n"
    "    OvernightIndexFutureRateHelper::OvernightIndexFutureRateHelper(Handle< Quote > const &,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &,Handle< Quote > const &)\n"
    "    OvernightIndexFutureRateHelper::OvernightIndexFutureRateHelper(Handle< Quote > const &,Date const &,Date const &,ext::shared_ptr< OvernightIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIndexFutureRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIndexFutureRateHelper *arg1 = (OvernightIndexFutureRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIndexFutureRateHelper > tempshared1 ;
  ext::shared_ptr< OvernightIndexFutureRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIndexFutureRateHelper" "', argument " "1"" of type '" "OvernightIndexFutureRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIndexFutureRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIndexFutureRateHelper > * >(argp1);
      arg1 = const_cast< OvernightIndexFutureRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIndexFutureRateHelper > * >(argp1);
      arg1 = const_cast< OvernightIndexFutureRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIndexFutureRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIndexFutureRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SofrFutureRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  Handle< Quote > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SofrFutureRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SofrFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SofrFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SofrFutureRateHelper" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SofrFutureRateHelper" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SofrFutureRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SofrFutureRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SofrFutureRateHelper" "', argument " "5"" of type '" "Handle< Quote > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< Quote > * >(argp5);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4,(Handle< Quote > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SofrFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SofrFutureRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SofrFutureRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SofrFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SofrFutureRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SofrFutureRateHelper" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SofrFutureRateHelper" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SofrFutureRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper((Handle< Quote > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SofrFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SofrFutureRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  Real arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SofrFutureRateHelper *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SofrFutureRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SofrFutureRateHelper" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SofrFutureRateHelper" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SofrFutureRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SofrFutureRateHelper" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SofrFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SofrFutureRateHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Month arg2 ;
  Year arg3 ;
  Frequency arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SofrFutureRateHelper *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SofrFutureRateHelper" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SofrFutureRateHelper" "', argument " "2"" of type '" "Month""'");
  } 
  arg2 = static_cast< Month >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SofrFutureRateHelper" "', argument " "3"" of type '" "Year""'");
  } 
  arg3 = static_cast< Year >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SofrFutureRateHelper" "', argument " "4"" of type '" "Frequency""'");
  } 
  arg4 = static_cast< Frequency >(val4);
  {
    try {
      result = (SofrFutureRateHelper *)new SofrFutureRateHelper(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SofrFutureRateHelper > *smartresult = result ? new ext::shared_ptr<  SofrFutureRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SofrFutureRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SofrFutureRateHelper", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SofrFutureRateHelper__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SofrFutureRateHelper__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SofrFutureRateHelper__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SofrFutureRateHelper__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SofrFutureRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Handle< Quote > const &,Month,Year,Frequency,Handle< Quote > const &)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Handle< Quote > const &,Month,Year,Frequency)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Real,Month,Year,Frequency,Real)\n"
    "    SofrFutureRateHelper::SofrFutureRateHelper(Real,Month,Year,Frequency)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SofrFutureRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SofrFutureRateHelper *arg1 = (SofrFutureRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SofrFutureRateHelper > tempshared1 ;
  ext::shared_ptr< SofrFutureRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SofrFutureRateHelper" "', argument " "1"" of type '" "SofrFutureRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SofrFutureRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SofrFutureRateHelper > * >(argp1);
      arg1 = const_cast< SofrFutureRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SofrFutureRateHelper > * >(argp1);
      arg1 = const_cast< SofrFutureRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SofrFutureRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SofrFutureRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SofrFutureRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ConstNotionalCrossCurrencyBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > arg7 ;
  ext::shared_ptr< IborIndex > arg8 ;
  Handle< YieldTermStructure > arg9 ;
  bool arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject *swig_obj[11] ;
  ConstNotionalCrossCurrencyBasisSwapRateHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ConstNotionalCrossCurrencyBasisSwapRateHelper", 11, 11, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp7) arg7 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp8) arg8 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (ConstNotionalCrossCurrencyBasisSwapRateHelper *)new ConstNotionalCrossCurrencyBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConstNotionalCrossCurrencyBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstNotionalCrossCurrencyBasisSwapRateHelper *arg1 = (ConstNotionalCrossCurrencyBasisSwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > tempshared1 ;
  ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstNotionalCrossCurrencyBasisSwapRateHelper" "', argument " "1"" of type '" "ConstNotionalCrossCurrencyBasisSwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< ConstNotionalCrossCurrencyBasisSwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< ConstNotionalCrossCurrencyBasisSwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstNotionalCrossCurrencyBasisSwapRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstNotionalCrossCurrencyBasisSwapRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MtMCrossCurrencyBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > arg7 ;
  ext::shared_ptr< IborIndex > arg8 ;
  Handle< YieldTermStructure > arg9 ;
  bool arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  MtMCrossCurrencyBasisSwapRateHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MtMCrossCurrencyBasisSwapRateHelper", 12, 12, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp7) arg7 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp8) arg8 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (MtMCrossCurrencyBasisSwapRateHelper *)new MtMCrossCurrencyBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MtMCrossCurrencyBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MtMCrossCurrencyBasisSwapRateHelper *arg1 = (MtMCrossCurrencyBasisSwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > tempshared1 ;
  ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MtMCrossCurrencyBasisSwapRateHelper" "', argument " "1"" of type '" "MtMCrossCurrencyBasisSwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< MtMCrossCurrencyBasisSwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< MtMCrossCurrencyBasisSwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MtMCrossCurrencyBasisSwapRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MtMCrossCurrencyBasisSwapRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IborIborBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Handle< YieldTermStructure > arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  void *argp9 ;
  int res9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  PyObject *swig_obj[10] ;
  IborIborBasisSwapRateHelper *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IborIborBasisSwapRateHelper", 10, 10, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_IborIborBasisSwapRateHelper" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (IborIborBasisSwapRateHelper *)new IborIborBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IborIborBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  IborIborBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IborIborBasisSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IborIborBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IborIborBasisSwapRateHelper *arg1 = (IborIborBasisSwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIborBasisSwapRateHelper > tempshared1 ;
  ext::shared_ptr< IborIborBasisSwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIborBasisSwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IborIborBasisSwapRateHelper" "', argument " "1"" of type '" "IborIborBasisSwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IborIborBasisSwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IborIborBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< IborIborBasisSwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IborIborBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< IborIborBasisSwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IborIborBasisSwapRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IborIborBasisSwapRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IborIborBasisSwapRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OvernightIborBasisSwapRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< OvernightIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  Handle< YieldTermStructure > arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared7 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  void *argp9 ;
  int res9 = 0 ;
  OvernightIborBasisSwapRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp7) : &tempshared7;
    }
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "9"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    try {
      result = (OvernightIborBasisSwapRateHelper *)new OvernightIborBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< OvernightIndex > const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIborBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  OvernightIborBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIborBasisSwapRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Natural arg3 ;
  SwigValueWrapper< Calendar > arg4 ;
  BusinessDayConvention arg5 ;
  bool arg6 ;
  ext::shared_ptr< OvernightIndex > *arg7 = 0 ;
  ext::shared_ptr< IborIndex > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< OvernightIndex > tempshared7 ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< IborIndex > tempshared8 ;
  OvernightIborBasisSwapRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "3"" of type '" "Natural""'");
  } 
  arg3 = static_cast< Natural >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "4"" of type '" "Calendar""'");
    } else {
      Calendar * temp = reinterpret_cast< Calendar * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "7"" of type '" "ext::shared_ptr< OvernightIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp7) : &tempshared7;
    }
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_OvernightIborBasisSwapRateHelper" "', argument " "8"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (OvernightIborBasisSwapRateHelper *)new OvernightIborBasisSwapRateHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< OvernightIndex > const &)*arg7,(ext::shared_ptr< IborIndex > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OvernightIborBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  OvernightIborBasisSwapRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OvernightIborBasisSwapRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_OvernightIborBasisSwapRateHelper", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_OvernightIborBasisSwapRateHelper__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_OvernightIborBasisSwapRateHelper__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OvernightIborBasisSwapRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    OvernightIborBasisSwapRateHelper::OvernightIborBasisSwapRateHelper(Handle< Quote > const &,Period const &,Natural,Calendar,BusinessDayConvention,bool,ext::shared_ptr< OvernightIndex > const &,ext::shared_ptr< IborIndex > const &,Handle< YieldTermStructure >)\n"
    "    OvernightIborBasisSwapRateHelper::OvernightIborBasisSwapRateHelper(Handle< Quote > const &,Period const &,Natural,Calendar,BusinessDayConvention,bool,ext::shared_ptr< OvernightIndex > const &,ext::shared_ptr< IborIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OvernightIborBasisSwapRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OvernightIborBasisSwapRateHelper *arg1 = (OvernightIborBasisSwapRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OvernightIborBasisSwapRateHelper > tempshared1 ;
  ext::shared_ptr< OvernightIborBasisSwapRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OvernightIborBasisSwapRateHelper" "', argument " "1"" of type '" "OvernightIborBasisSwapRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OvernightIborBasisSwapRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OvernightIborBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< OvernightIborBasisSwapRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OvernightIborBasisSwapRateHelper > * >(argp1);
      arg1 = const_cast< OvernightIborBasisSwapRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OvernightIborBasisSwapRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OvernightIborBasisSwapRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ArithmeticOISRateHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Real arg9 ;
  bool arg10 ;
  Handle< YieldTermStructure > arg11 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  void *argp11 ;
  int res11 = 0 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticOISRateHelper" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ArithmeticOISRateHelper" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticOISRateHelper" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ArithmeticOISRateHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticOISRateHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticOISRateHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ArithmeticOISRateHelper" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_ArithmeticOISRateHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp11) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
      arg11 = *temp;
      if (SWIG_IsNewObj(res11)) delete temp;
    }
  }
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticOISRateHelper > *smartresult = result ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticOISRateHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Real arg9 ;
  bool arg10 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticOISRateHelper" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ArithmeticOISRateHelper" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticOISRateHelper" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ArithmeticOISRateHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticOISRateHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticOISRateHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ArithmeticOISRateHelper" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticOISRateHelper > *smartresult = result ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticOISRateHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  Real arg9 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticOISRateHelper" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ArithmeticOISRateHelper" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticOISRateHelper" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ArithmeticOISRateHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticOISRateHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ArithmeticOISRateHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticOISRateHelper > *smartresult = result ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticOISRateHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  Real arg8 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticOISRateHelper" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ArithmeticOISRateHelper" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticOISRateHelper" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ArithmeticOISRateHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ArithmeticOISRateHelper" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticOISRateHelper > *smartresult = result ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticOISRateHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Period *arg2 = 0 ;
  Frequency arg3 ;
  Handle< Quote > *arg4 = 0 ;
  ext::shared_ptr< OvernightIndex > arg5 ;
  Frequency arg6 ;
  Handle< Quote > arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ArithmeticOISRateHelper *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArithmeticOISRateHelper" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ArithmeticOISRateHelper" "', argument " "3"" of type '" "Frequency""'");
  } 
  arg3 = static_cast< Frequency >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ArithmeticOISRateHelper" "', argument " "5"" of type '" "ext::shared_ptr< OvernightIndex >""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< OvernightIndex > * >(argp5);
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ArithmeticOISRateHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArithmeticOISRateHelper" "', argument " "7"" of type '" "Handle< Quote >""'");
    } else {
      Handle< Quote > * temp = reinterpret_cast< Handle< Quote > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (ArithmeticOISRateHelper *)new ArithmeticOISRateHelper(arg1,(Period const &)*arg2,arg3,(Handle< Quote > const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticOISRateHelper > *smartresult = result ? new ext::shared_ptr<  ArithmeticOISRateHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ArithmeticOISRateHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ArithmeticOISRateHelper", 0, 11, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ArithmeticOISRateHelper__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ArithmeticOISRateHelper__SWIG_3(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ArithmeticOISRateHelper__SWIG_2(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ArithmeticOISRateHelper__SWIG_1(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_OvernightIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_ArithmeticOISRateHelper__SWIG_0(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ArithmeticOISRateHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ArithmeticOISRateHelper::ArithmeticOISRateHelper(Natural,Period const &,Frequency,Handle< Quote > const &,ext::shared_ptr< OvernightIndex >,Frequency,Handle< Quote >,Real,Real,bool,Handle< YieldTermStructure >)\n"
    "    ArithmeticOISRateHelper::ArithmeticOISRateHelper(Natural,Period const &,Frequency,Handle< Quote > const &,ext::shared_ptr< OvernightIndex >,Frequency,Handle< Quote >,Real,Real,bool)\n"
    "    ArithmeticOISRateHelper::ArithmeticOISRateHelper(Natural,Period const &,Frequency,Handle< Quote > const &,ext::shared_ptr< OvernightIndex >,Frequency,Handle< Quote >,Real,Real)\n"
    "    ArithmeticOISRateHelper::ArithmeticOISRateHelper(Natural,Period const &,Frequency,Handle< Quote > const &,ext::shared_ptr< OvernightIndex >,Frequency,Handle< Quote >,Real)\n"
    "    ArithmeticOISRateHelper::ArithmeticOISRateHelper(Natural,Period const &,Frequency,Handle< Quote > const &,ext::shared_ptr< OvernightIndex >,Frequency,Handle< Quote >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ArithmeticOISRateHelper_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticOISRateHelper *arg1 = (ArithmeticOISRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticOISRateHelper const > tempshared1 ;
  ext::shared_ptr< ArithmeticOISRateHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ArithmeticAverageOIS > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArithmeticOISRateHelper_swap" "', argument " "1"" of type '" "ArithmeticOISRateHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ArithmeticOISRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ArithmeticOISRateHelper > * >(argp1);
      arg1 = const_cast< ArithmeticOISRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ArithmeticOISRateHelper > * >(argp1);
      arg1 = const_cast< ArithmeticOISRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ArithmeticOISRateHelper const *)arg1)->swap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ArithmeticAverageOIS > *smartresult = result ? new ext::shared_ptr<  ArithmeticAverageOIS >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ArithmeticAverageOIS_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ArithmeticOISRateHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ArithmeticOISRateHelper *arg1 = (ArithmeticOISRateHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ArithmeticOISRateHelper > tempshared1 ;
  ext::shared_ptr< ArithmeticOISRateHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArithmeticOISRateHelper" "', argument " "1"" of type '" "ArithmeticOISRateHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ArithmeticOISRateHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ArithmeticOISRateHelper > * >(argp1);
      arg1 = const_cast< ArithmeticOISRateHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ArithmeticOISRateHelper > * >(argp1);
      arg1 = const_cast< ArithmeticOISRateHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ArithmeticOISRateHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ArithmeticOISRateHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ArithmeticOISRateHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RateHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< RateHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____bool__((std::vector< ext::shared_ptr< RateHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____len__((std::vector< ext::shared_ptr< RateHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RateHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RateHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RateHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RateHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RateHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RateHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RateHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__setslice__(std::vector< ext::shared_ptr< RateHelper > >::difference_type,std::vector< ext::shared_ptr< RateHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__setslice__(std::vector< ext::shared_ptr< RateHelper > >::difference_type,std::vector< ext::shared_ptr< RateHelper > >::difference_type,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RateHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RateHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RateHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RateHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RateHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__delitem__(std::vector< ext::shared_ptr< RateHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< RateHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< RateHelper > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RateHelper > *smartresult = *result ? new ext::shared_ptr<  RateHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< RateHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RateHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RateHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__getitem__(std::vector< ext::shared_ptr< RateHelper > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RateHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< RateHelper > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_RateHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RateHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RateHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::__setitem__(std::vector< ext::shared_ptr< RateHelper > >::difference_type,std::vector< ext::shared_ptr< RateHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RateHelper > *smartresult = result ? new ext::shared_ptr<  RateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RateHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__append(arg1,(ext::shared_ptr< RateHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > > *)new std::vector< ext::shared_ptr< RateHelper > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RateHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RateHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > > *)new std::vector< ext::shared_ptr< RateHelper > >((std::vector< ext::shared_ptr< RateHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< RateHelper > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< RateHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RateHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RateHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< RateHelper > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< RateHelper > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< RateHelper > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_RateHelper_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RateHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > > *)new std::vector< ext::shared_ptr< RateHelper > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_RateHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_RateHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::erase(std::vector< ext::shared_ptr< RateHelper > >::iterator)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::erase(std::vector< ext::shared_ptr< RateHelper > >::iterator,std::vector< ext::shared_ptr< RateHelper > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_RateHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg1 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< RateHelper > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RateHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RateHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > > *)new std::vector< ext::shared_ptr< RateHelper > >(arg1,(std::vector< ext::shared_ptr< RateHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RateHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RateHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RateHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RateHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RateHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RateHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::vector()\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::vector(std::vector< ext::shared_ptr< RateHelper > > const &)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::vector(std::vector< ext::shared_ptr< RateHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::vector(std::vector< ext::shared_ptr< RateHelper > >::size_type,std::vector< ext::shared_ptr< RateHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RateHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< RateHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > >::value_type *) &((std::vector< ext::shared_ptr< RateHelper > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RateHelper > *smartresult = *result ? new ext::shared_ptr<  RateHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< RateHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< RateHelper > >::value_type *) &((std::vector< ext::shared_ptr< RateHelper > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RateHelper > *smartresult = *result ? new ext::shared_ptr<  RateHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< RateHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RateHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< RateHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RateHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< RateHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RateHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RateHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::resize(std::vector< ext::shared_ptr< RateHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::resize(std::vector< ext::shared_ptr< RateHelper > >::size_type,std::vector< ext::shared_ptr< RateHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RateHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< RateHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< RateHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg3 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "RateHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RateHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RateHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_RateHelper_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< RateHelper > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RateHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RateHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< RateHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RateHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RateHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::insert(std::vector< ext::shared_ptr< RateHelper > >::iterator,std::vector< ext::shared_ptr< RateHelper > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< RateHelper > >::insert(std::vector< ext::shared_ptr< RateHelper > >::iterator,std::vector< ext::shared_ptr< RateHelper > >::size_type,std::vector< ext::shared_ptr< RateHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RateHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RateHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< RateHelper > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RateHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< RateHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RateHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< RateHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RateHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper > > *arg1 = (std::vector< ext::shared_ptr< RateHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RateHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< RateHelper > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RateHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_RateHelper_t_std__allocatorT_ext__shared_ptrT_RateHelper_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RateHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BondHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< BondHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____bool__((std::vector< ext::shared_ptr< BondHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____len__((std::vector< ext::shared_ptr< BondHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BondHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BondHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__setslice__(std::vector< ext::shared_ptr< BondHelper > >::difference_type,std::vector< ext::shared_ptr< BondHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__setslice__(std::vector< ext::shared_ptr< BondHelper > >::difference_type,std::vector< ext::shared_ptr< BondHelper > >::difference_type,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BondHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BondHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__delitem__(std::vector< ext::shared_ptr< BondHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< BondHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< BondHelper > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondHelper > *smartresult = *result ? new ext::shared_ptr<  BondHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BondHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BondHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BondHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__getitem__(std::vector< ext::shared_ptr< BondHelper > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BondHelper > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_BondHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::__setitem__(std::vector< ext::shared_ptr< BondHelper > >::difference_type,std::vector< ext::shared_ptr< BondHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondHelper > *smartresult = result ? new ext::shared_ptr<  BondHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__append(arg1,(ext::shared_ptr< BondHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > > *)new std::vector< ext::shared_ptr< BondHelper > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BondHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BondHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > > *)new std::vector< ext::shared_ptr< BondHelper > >((std::vector< ext::shared_ptr< BondHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< BondHelper > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BondHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BondHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< BondHelper > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BondHelper > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< BondHelper > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_BondHelper_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BondHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > > *)new std::vector< ext::shared_ptr< BondHelper > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_BondHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_BondHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::erase(std::vector< ext::shared_ptr< BondHelper > >::iterator)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::erase(std::vector< ext::shared_ptr< BondHelper > >::iterator,std::vector< ext::shared_ptr< BondHelper > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_BondHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg1 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< BondHelper > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BondHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BondHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > > *)new std::vector< ext::shared_ptr< BondHelper > >(arg1,(std::vector< ext::shared_ptr< BondHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BondHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BondHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_BondHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BondHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BondHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BondHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BondHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::vector()\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::vector(std::vector< ext::shared_ptr< BondHelper > > const &)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::vector(std::vector< ext::shared_ptr< BondHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::vector(std::vector< ext::shared_ptr< BondHelper > >::size_type,std::vector< ext::shared_ptr< BondHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BondHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< BondHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > >::value_type *) &((std::vector< ext::shared_ptr< BondHelper > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondHelper > *smartresult = *result ? new ext::shared_ptr<  BondHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BondHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< BondHelper > >::value_type *) &((std::vector< ext::shared_ptr< BondHelper > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BondHelper > *smartresult = *result ? new ext::shared_ptr<  BondHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< BondHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< BondHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< BondHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BondHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::resize(std::vector< ext::shared_ptr< BondHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::resize(std::vector< ext::shared_ptr< BondHelper > >::size_type,std::vector< ext::shared_ptr< BondHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BondHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< BondHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< BondHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg3 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BondHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BondHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BondHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_BondHelper_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< BondHelper > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "BondHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BondHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< BondHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_BondHelper_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BondHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BondHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::insert(std::vector< ext::shared_ptr< BondHelper > >::iterator,std::vector< ext::shared_ptr< BondHelper > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< BondHelper > >::insert(std::vector< ext::shared_ptr< BondHelper > >::iterator,std::vector< ext::shared_ptr< BondHelper > >::size_type,std::vector< ext::shared_ptr< BondHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "BondHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BondHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< BondHelper > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BondHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< BondHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BondHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< BondHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BondHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< BondHelper > > *arg1 = (std::vector< ext::shared_ptr< BondHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BondHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< BondHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< BondHelper > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BondHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_BondHelper_t_std__allocatorT_ext__shared_ptrT_BondHelper_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BondHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_as_depositratehelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< RateHelper > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< DepositRateHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_depositratehelper" "', argument " "1"" of type '" "ext::shared_ptr< RateHelper > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1);
  }
  {
    try {
      result = as_depositratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DepositRateHelper > *smartresult = result ? new ext::shared_ptr<  DepositRateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DepositRateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_as_fraratehelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< RateHelper > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FraRateHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_fraratehelper" "', argument " "1"" of type '" "ext::shared_ptr< RateHelper > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1);
  }
  {
    try {
      result = as_fraratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FraRateHelper > *smartresult = result ? new ext::shared_ptr<  FraRateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FraRateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_as_swapratehelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< RateHelper > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SwapRateHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_swapratehelper" "', argument " "1"" of type '" "ext::shared_ptr< RateHelper > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1);
  }
  {
    try {
      result = as_swapratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SwapRateHelper > *smartresult = result ? new ext::shared_ptr<  SwapRateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SwapRateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_as_oisratehelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< RateHelper > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< OISRateHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_oisratehelper" "', argument " "1"" of type '" "ext::shared_ptr< RateHelper > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1);
  }
  {
    try {
      result = as_oisratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OISRateHelper > *smartresult = result ? new ext::shared_ptr<  OISRateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OISRateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_as_constnotionalcrosscurrencybasisswapratehelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< RateHelper > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_constnotionalcrosscurrencybasisswapratehelper" "', argument " "1"" of type '" "ext::shared_ptr< RateHelper > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1);
  }
  {
    try {
      result = as_constnotionalcrosscurrencybasisswapratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  ConstNotionalCrossCurrencyBasisSwapRateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_as_mtmcrosscurrencybasisswapratehelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< RateHelper > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RateHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "as_mtmcrosscurrencybasisswapratehelper" "', argument " "1"" of type '" "ext::shared_ptr< RateHelper > const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< RateHelper > * >(argp1);
  }
  {
    try {
      result = as_mtmcrosscurrencybasisswapratehelper(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper > *smartresult = result ? new ext::shared_ptr<  MtMCrossCurrencyBasisSwapRateHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Discount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Discount *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Discount", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Discount *)new Discount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Discount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Discount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Discount *arg1 = (Discount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Discount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Discount" "', argument " "1"" of type '" "Discount *""'"); 
  }
  arg1 = reinterpret_cast< Discount * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Discount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Discount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Discount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZeroYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroYield *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ZeroYield", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ZeroYield *)new ZeroYield();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ZeroYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroYield(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ZeroYield *arg1 = (ZeroYield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ZeroYield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroYield" "', argument " "1"" of type '" "ZeroYield *""'"); 
  }
  arg1 = reinterpret_cast< ZeroYield * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroYield_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ZeroYield, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroYield_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRate *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ForwardRate", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ForwardRate *)new ForwardRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ForwardRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRate *arg1 = (ForwardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ForwardRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardRate" "', argument " "1"" of type '" "ForwardRate *""'"); 
  }
  arg1 = reinterpret_cast< ForwardRate * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ForwardRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IterativeBootstrap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  doubleOrNull arg1 = (doubleOrNull) Null< double >() ;
  doubleOrNull arg2 = (doubleOrNull) Null< double >() ;
  doubleOrNull arg3 = (doubleOrNull) Null< double >() ;
  Size arg4 = (Size) 1 ;
  Real arg5 = (Real) 2.0 ;
  Real arg6 = (Real) 2.0 ;
  bool arg7 = (bool) false ;
  Size arg8 = (Size) 10 ;
  Size arg9 = (Size) 100 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 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 ;
  char * kwnames[] = {
    (char *)"accuracy",  (char *)"minValue",  (char *)"maxValue",  (char *)"maxAttempts",  (char *)"maxFactor",  (char *)"minFactor",  (char *)"dontThrow",  (char *)"dontThrowSteps",  (char *)"maxEvaluations",  NULL 
  };
  _IterativeBootstrap *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOOOOOOO:new_IterativeBootstrap", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  if (obj0) {
    {
      if (obj0 == Py_None)
      arg1 = Null<double>();
      else if (PyFloat_Check(obj0))
      arg1 = PyFloat_AsDouble(obj0);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj1) {
    {
      if (obj1 == Py_None)
      arg2 = Null<double>();
      else if (PyFloat_Check(obj1))
      arg2 = PyFloat_AsDouble(obj1);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj2) {
    {
      if (obj2 == Py_None)
      arg3 = Null<double>();
      else if (PyFloat_Check(obj2))
      arg3 = PyFloat_AsDouble(obj2);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_size_t(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IterativeBootstrap" "', argument " "4"" of type '" "Size""'");
    } 
    arg4 = static_cast< Size >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_double(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IterativeBootstrap" "', argument " "5"" of type '" "Real""'");
    } 
    arg5 = static_cast< Real >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_double(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IterativeBootstrap" "', argument " "6"" of type '" "Real""'");
    } 
    arg6 = static_cast< Real >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_bool(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_IterativeBootstrap" "', argument " "7"" of type '" "bool""'");
    } 
    arg7 = static_cast< bool >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_size_t(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_IterativeBootstrap" "', argument " "8"" of type '" "Size""'");
    } 
    arg8 = static_cast< Size >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_size_t(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_IterativeBootstrap" "', argument " "9"" of type '" "Size""'");
    } 
    arg9 = static_cast< Size >(val9);
  }
  {
    try {
      result = (_IterativeBootstrap *)new _IterativeBootstrap(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IterativeBootstrap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _IterativeBootstrap *arg1 = (_IterativeBootstrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IterativeBootstrap" "', argument " "1"" of type '" "_IterativeBootstrap *""'"); 
  }
  arg1 = reinterpret_cast< _IterativeBootstrap * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IterativeBootstrap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__IterativeBootstrap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IterativeBootstrap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  BackwardFlat *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  arg6 = reinterpret_cast< BackwardFlat * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(BackwardFlat const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  BackwardFlat *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  arg6 = reinterpret_cast< BackwardFlat * >(argp6);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(BackwardFlat const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  BackwardFlat *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "BackwardFlat const &""'"); 
  }
  arg7 = reinterpret_cast< BackwardFlat * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseFlatForward" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(BackwardFlat const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  BackwardFlat *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "7"" of type '" "BackwardFlat const &""'"); 
  }
  arg7 = reinterpret_cast< BackwardFlat * >(argp7);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(BackwardFlat const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  arg5 = reinterpret_cast< BackwardFlat * >(argp5);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  BackwardFlat *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "6"" of type '" "BackwardFlat const &""'"); 
  }
  arg6 = reinterpret_cast< BackwardFlat * >(argp6);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(BackwardFlat const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseFlatForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseFlatForward *)new_PiecewiseFlatForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatForward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseFlatForward", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseFlatForward__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseFlatForward__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseFlatForward__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseFlatForward__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatForward__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatForward__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatForward__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatForward__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseFlatForward__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseFlatForward__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseFlatForward__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseFlatForward__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseFlatForward__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseFlatForward__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseFlatForward'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,BackwardFlat const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,BackwardFlat const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,BackwardFlat const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,BackwardFlat const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,BackwardFlat const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,BackwardFlat const &)\n"
    "    PiecewiseFlatForward::PiecewiseFlatForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatForward_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatForward_dates" "', argument " "1"" of type '" "PiecewiseFlatForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseFlatForward const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatForward_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatForward_times" "', argument " "1"" of type '" "PiecewiseFlatForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseFlatForward const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatForward_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatForward_nodes" "', argument " "1"" of type '" "PiecewiseFlatForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseFlatForward const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatForward_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatForward_recalculate" "', argument " "1"" of type '" "PiecewiseFlatForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatForward_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatForward_freeze" "', argument " "1"" of type '" "PiecewiseFlatForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatForward_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatForward_unfreeze" "', argument " "1"" of type '" "PiecewiseFlatForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseFlatForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatForward *arg1 = (PiecewiseFlatForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatForward > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseFlatForward" "', argument " "1"" of type '" "PiecewiseFlatForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseFlatForward > * >(argp1);
      arg1 = const_cast< PiecewiseFlatForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseFlatForward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatForward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseFlatForward_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  LogLinear *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "LogLinear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "LogLinear const &""'"); 
  }
  arg6 = reinterpret_cast< LogLinear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(LogLinear const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  LogLinear *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "LogLinear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "LogLinear const &""'"); 
  }
  arg6 = reinterpret_cast< LogLinear * >(argp6);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(LogLinear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  LogLinear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "LogLinear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "LogLinear const &""'"); 
  }
  arg7 = reinterpret_cast< LogLinear * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(LogLinear const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  LogLinear *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "LogLinear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "7"" of type '" "LogLinear const &""'"); 
  }
  arg7 = reinterpret_cast< LogLinear * >(argp7);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(LogLinear const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  arg5 = reinterpret_cast< LogLinear * >(argp5);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(LogLinear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  LogLinear *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "LogLinear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "6"" of type '" "LogLinear const &""'"); 
  }
  arg6 = reinterpret_cast< LogLinear * >(argp6);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(LogLinear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLogLinearDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogLinearDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseLogLinearDiscount *)new_PiecewiseLogLinearDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogLinearDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogLinearDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogLinearDiscount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLogLinearDiscount", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseLogLinearDiscount__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogLinearDiscount__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogLinearDiscount__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogLinearDiscount__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogLinearDiscount__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogLinearDiscount__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogLinearDiscount__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogLinearDiscount__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogLinearDiscount__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogLinearDiscount__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogLinearDiscount__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLogLinearDiscount__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLogLinearDiscount__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLogLinearDiscount__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseLogLinearDiscount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogLinear const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogLinear const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogLinear const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogLinear const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,LogLinear const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,LogLinear const &)\n"
    "    PiecewiseLogLinearDiscount::PiecewiseLogLinearDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogLinearDiscount_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogLinearDiscount_dates" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseLogLinearDiscount const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogLinearDiscount_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogLinearDiscount_times" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseLogLinearDiscount const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogLinearDiscount_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogLinearDiscount_nodes" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseLogLinearDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogLinearDiscount_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogLinearDiscount_recalculate" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogLinearDiscount_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogLinearDiscount_freeze" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogLinearDiscount_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogLinearDiscount_unfreeze" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseLogLinearDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogLinearDiscount *arg1 = (PiecewiseLogLinearDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogLinearDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseLogLinearDiscount" "', argument " "1"" of type '" "PiecewiseLogLinearDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogLinearDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogLinearDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseLogLinearDiscount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseLogLinearDiscount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Linear const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Linear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  arg7 = reinterpret_cast< Linear * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLinearForward" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Linear const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  arg7 = reinterpret_cast< Linear * >(argp7);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Linear *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Linear *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Linear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLinearForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseLinearForward *)new_PiecewiseLinearForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearForward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLinearForward", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseLinearForward__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLinearForward__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLinearForward__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLinearForward__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearForward__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearForward__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearForward__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearForward__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLinearForward__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLinearForward__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLinearForward__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLinearForward__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLinearForward__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLinearForward__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseLinearForward'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Linear const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Linear const &)\n"
    "    PiecewiseLinearForward::PiecewiseLinearForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearForward_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearForward_dates" "', argument " "1"" of type '" "PiecewiseLinearForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseLinearForward const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearForward_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearForward_times" "', argument " "1"" of type '" "PiecewiseLinearForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseLinearForward const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearForward_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearForward_nodes" "', argument " "1"" of type '" "PiecewiseLinearForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseLinearForward const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearForward_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearForward_recalculate" "', argument " "1"" of type '" "PiecewiseLinearForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearForward_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearForward_freeze" "', argument " "1"" of type '" "PiecewiseLinearForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearForward_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearForward_unfreeze" "', argument " "1"" of type '" "PiecewiseLinearForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseLinearForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearForward *arg1 = (PiecewiseLinearForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearForward > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseLinearForward" "', argument " "1"" of type '" "PiecewiseLinearForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearForward > * >(argp1);
      arg1 = const_cast< PiecewiseLinearForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseLinearForward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearForward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseLinearForward_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Linear const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Linear *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Linear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  arg7 = reinterpret_cast< Linear * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLinearZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Linear const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Linear *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "7"" of type '" "Linear const &""'"); 
  }
  arg7 = reinterpret_cast< Linear * >(argp7);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Linear const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Linear *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Linear *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "6"" of type '" "Linear const &""'"); 
  }
  arg6 = reinterpret_cast< Linear * >(argp6);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Linear const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLinearZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLinearZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLinearZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseLinearZero *)new_PiecewiseLinearZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLinearZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseLinearZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLinearZero(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLinearZero", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseLinearZero__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLinearZero__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLinearZero__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLinearZero__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearZero__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearZero__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearZero__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLinearZero__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLinearZero__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLinearZero__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLinearZero__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLinearZero__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLinearZero__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLinearZero__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseLinearZero'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Linear const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Linear const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Linear const &)\n"
    "    PiecewiseLinearZero::PiecewiseLinearZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearZero_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearZero_dates" "', argument " "1"" of type '" "PiecewiseLinearZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseLinearZero const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearZero_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearZero_times" "', argument " "1"" of type '" "PiecewiseLinearZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseLinearZero const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearZero_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearZero_nodes" "', argument " "1"" of type '" "PiecewiseLinearZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseLinearZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearZero_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearZero_recalculate" "', argument " "1"" of type '" "PiecewiseLinearZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearZero_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearZero_freeze" "', argument " "1"" of type '" "PiecewiseLinearZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLinearZero_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLinearZero_unfreeze" "', argument " "1"" of type '" "PiecewiseLinearZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseLinearZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLinearZero *arg1 = (PiecewiseLinearZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLinearZero > tempshared1 ;
  ext::shared_ptr< PiecewiseLinearZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseLinearZero" "', argument " "1"" of type '" "PiecewiseLinearZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLinearZero > * >(argp1);
      arg1 = const_cast< PiecewiseLinearZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseLinearZero_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseLinearZero_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseLinearZero_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Cubic const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Cubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Cubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Cubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Cubic const &""'"); 
  }
  arg7 = reinterpret_cast< Cubic * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseCubicZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Cubic const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Cubic *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Cubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "7"" of type '" "Cubic const &""'"); 
  }
  arg7 = reinterpret_cast< Cubic * >(argp7);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Cubic const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(Cubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Cubic *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "6"" of type '" "Cubic const &""'"); 
  }
  arg6 = reinterpret_cast< Cubic * >(argp6);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Cubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseCubicZero *)new_PiecewiseCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseCubicZero(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseCubicZero", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseCubicZero__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseCubicZero__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseCubicZero__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseCubicZero__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseCubicZero__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseCubicZero__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseCubicZero__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseCubicZero__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseCubicZero__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseCubicZero__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseCubicZero__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseCubicZero__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseCubicZero__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseCubicZero__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseCubicZero'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Cubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Cubic const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Cubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Cubic const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Cubic const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Cubic const &)\n"
    "    PiecewiseCubicZero::PiecewiseCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseCubicZero_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseCubicZero_dates" "', argument " "1"" of type '" "PiecewiseCubicZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseCubicZero const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseCubicZero_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseCubicZero_times" "', argument " "1"" of type '" "PiecewiseCubicZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseCubicZero const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseCubicZero_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseCubicZero_nodes" "', argument " "1"" of type '" "PiecewiseCubicZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseCubicZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseCubicZero_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseCubicZero_recalculate" "', argument " "1"" of type '" "PiecewiseCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseCubicZero_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseCubicZero_freeze" "', argument " "1"" of type '" "PiecewiseCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseCubicZero_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseCubicZero_unfreeze" "', argument " "1"" of type '" "PiecewiseCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseCubicZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseCubicZero *arg1 = (PiecewiseCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseCubicZero" "', argument " "1"" of type '" "PiecewiseCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseCubicZero_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseCubicZero_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseCubicZero_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  MonotonicLogCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicLogCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(MonotonicLogCubic const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  MonotonicLogCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicLogCubic * >(argp6);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(MonotonicLogCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  MonotonicLogCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg7 = reinterpret_cast< MonotonicLogCubic * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(MonotonicLogCubic const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  MonotonicLogCubic *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "7"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg7 = reinterpret_cast< MonotonicLogCubic * >(argp7);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(MonotonicLogCubic const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  MonotonicLogCubic *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicLogCubic * >(argp5);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(MonotonicLogCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  MonotonicLogCubic *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "6"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg6 = reinterpret_cast< MonotonicLogCubic * >(argp6);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(MonotonicLogCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseLogCubicDiscount *)new_PiecewiseLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogCubicDiscount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLogCubicDiscount", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseLogCubicDiscount__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogCubicDiscount__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogCubicDiscount__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogCubicDiscount__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogCubicDiscount__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogCubicDiscount__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogCubicDiscount__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogCubicDiscount__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogCubicDiscount__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogCubicDiscount__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogCubicDiscount__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLogCubicDiscount__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLogCubicDiscount__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLogCubicDiscount__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseLogCubicDiscount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,MonotonicLogCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,MonotonicLogCubic const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,MonotonicLogCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,MonotonicLogCubic const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,MonotonicLogCubic const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,MonotonicLogCubic const &)\n"
    "    PiecewiseLogCubicDiscount::PiecewiseLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogCubicDiscount_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogCubicDiscount_dates" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseLogCubicDiscount const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogCubicDiscount_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogCubicDiscount_times" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseLogCubicDiscount const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogCubicDiscount_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogCubicDiscount_nodes" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseLogCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogCubicDiscount_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogCubicDiscount_recalculate" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogCubicDiscount_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogCubicDiscount_freeze" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogCubicDiscount_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogCubicDiscount_unfreeze" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseLogCubicDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogCubicDiscount *arg1 = (PiecewiseLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseLogCubicDiscount" "', argument " "1"" of type '" "PiecewiseLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseLogCubicDiscount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseLogCubicDiscount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(SplineCubic const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(SplineCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  arg7 = reinterpret_cast< SplineCubic * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(SplineCubic const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  arg7 = reinterpret_cast< SplineCubic * >(argp7);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(SplineCubic const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(SplineCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(SplineCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseSplineCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseSplineCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseSplineCubicDiscount *)new_PiecewiseSplineCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseSplineCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseSplineCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseSplineCubicDiscount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseSplineCubicDiscount", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseSplineCubicDiscount__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseSplineCubicDiscount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,SplineCubic const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,SplineCubic const &)\n"
    "    PiecewiseSplineCubicDiscount::PiecewiseSplineCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseSplineCubicDiscount_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseSplineCubicDiscount_dates" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseSplineCubicDiscount const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseSplineCubicDiscount_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseSplineCubicDiscount_times" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseSplineCubicDiscount const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseSplineCubicDiscount_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseSplineCubicDiscount_nodes" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseSplineCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseSplineCubicDiscount_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseSplineCubicDiscount_recalculate" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseSplineCubicDiscount_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseSplineCubicDiscount_freeze" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseSplineCubicDiscount_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseSplineCubicDiscount_unfreeze" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseSplineCubicDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseSplineCubicDiscount *arg1 = (PiecewiseSplineCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseSplineCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseSplineCubicDiscount" "', argument " "1"" of type '" "PiecewiseSplineCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseSplineCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseSplineCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseSplineCubicDiscount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseSplineCubicDiscount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Kruger *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Kruger const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Kruger const &""'"); 
  }
  arg6 = reinterpret_cast< Kruger * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Kruger const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  Kruger *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Kruger const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Kruger const &""'"); 
  }
  arg6 = reinterpret_cast< Kruger * >(argp6);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(Kruger const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Kruger *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Kruger const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Kruger const &""'"); 
  }
  arg7 = reinterpret_cast< Kruger * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseKrugerZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Kruger const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Kruger *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Kruger const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "7"" of type '" "Kruger const &""'"); 
  }
  arg7 = reinterpret_cast< Kruger * >(argp7);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(Kruger const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  Kruger *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  arg5 = reinterpret_cast< Kruger * >(argp5);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(Kruger const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  Kruger *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Kruger const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "6"" of type '" "Kruger const &""'"); 
  }
  arg6 = reinterpret_cast< Kruger * >(argp6);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(Kruger const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseKrugerZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseKrugerZero *)new_PiecewiseKrugerZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerZero(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseKrugerZero", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseKrugerZero__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseKrugerZero__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseKrugerZero__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseKrugerZero__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerZero__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerZero__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerZero__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerZero__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseKrugerZero__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseKrugerZero__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseKrugerZero__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseKrugerZero__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseKrugerZero__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseKrugerZero__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseKrugerZero'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Kruger const &,_IterativeBootstrap const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Kruger const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Kruger const &,_IterativeBootstrap const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,Kruger const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Kruger const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,Kruger const &)\n"
    "    PiecewiseKrugerZero::PiecewiseKrugerZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerZero_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerZero_dates" "', argument " "1"" of type '" "PiecewiseKrugerZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseKrugerZero const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerZero_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerZero_times" "', argument " "1"" of type '" "PiecewiseKrugerZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseKrugerZero const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerZero_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerZero_nodes" "', argument " "1"" of type '" "PiecewiseKrugerZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseKrugerZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerZero_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerZero_recalculate" "', argument " "1"" of type '" "PiecewiseKrugerZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerZero_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerZero_freeze" "', argument " "1"" of type '" "PiecewiseKrugerZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerZero_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerZero_unfreeze" "', argument " "1"" of type '" "PiecewiseKrugerZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseKrugerZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerZero *arg1 = (PiecewiseKrugerZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerZero > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseKrugerZero" "', argument " "1"" of type '" "PiecewiseKrugerZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerZero > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseKrugerZero_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerZero_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseKrugerZero_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  KrugerLog *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "KrugerLog const &""'"); 
  }
  arg6 = reinterpret_cast< KrugerLog * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(KrugerLog const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  KrugerLog *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "KrugerLog const &""'"); 
  }
  arg6 = reinterpret_cast< KrugerLog * >(argp6);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(KrugerLog const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  KrugerLog *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "KrugerLog const &""'"); 
  }
  arg7 = reinterpret_cast< KrugerLog * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(KrugerLog const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  KrugerLog *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "7"" of type '" "KrugerLog const &""'"); 
  }
  arg7 = reinterpret_cast< KrugerLog * >(argp7);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(KrugerLog const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  KrugerLog *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "KrugerLog const &""'"); 
  }
  arg5 = reinterpret_cast< KrugerLog * >(argp5);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(KrugerLog const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  KrugerLog *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "6"" of type '" "KrugerLog const &""'"); 
  }
  arg6 = reinterpret_cast< KrugerLog * >(argp6);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(KrugerLog const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseKrugerLogDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseKrugerLogDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseKrugerLogDiscount *)new_PiecewiseKrugerLogDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseKrugerLogDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseKrugerLogDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseKrugerLogDiscount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseKrugerLogDiscount", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseKrugerLogDiscount__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseKrugerLogDiscount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,KrugerLog const &,_IterativeBootstrap const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,KrugerLog const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,KrugerLog const &,_IterativeBootstrap const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,KrugerLog const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,KrugerLog const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,KrugerLog const &)\n"
    "    PiecewiseKrugerLogDiscount::PiecewiseKrugerLogDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerLogDiscount_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerLogDiscount_dates" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseKrugerLogDiscount const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerLogDiscount_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerLogDiscount_times" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseKrugerLogDiscount const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerLogDiscount_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerLogDiscount_nodes" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseKrugerLogDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerLogDiscount_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerLogDiscount_recalculate" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerLogDiscount_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerLogDiscount_freeze" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseKrugerLogDiscount_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseKrugerLogDiscount_unfreeze" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseKrugerLogDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseKrugerLogDiscount *arg1 = (PiecewiseKrugerLogDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseKrugerLogDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseKrugerLogDiscount" "', argument " "1"" of type '" "PiecewiseKrugerLogDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseKrugerLogDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseKrugerLogDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseKrugerLogDiscount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseKrugerLogDiscount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  arg6 = reinterpret_cast< ConvexMonotone * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(ConvexMonotone const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  arg6 = reinterpret_cast< ConvexMonotone * >(argp6);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(ConvexMonotone const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  arg7 = reinterpret_cast< ConvexMonotone * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(ConvexMonotone const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  arg7 = reinterpret_cast< ConvexMonotone * >(argp7);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(ConvexMonotone const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  ConvexMonotone *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "ConvexMonotone const &""'"); 
  }
  arg5 = reinterpret_cast< ConvexMonotone * >(argp5);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(ConvexMonotone const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  arg6 = reinterpret_cast< ConvexMonotone * >(argp6);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(ConvexMonotone const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseConvexMonotoneForward *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneForward" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseConvexMonotoneForward *)new_PiecewiseConvexMonotoneForward__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneForward > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneForward >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneForward(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseConvexMonotoneForward", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseConvexMonotoneForward__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseConvexMonotoneForward'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &,_IterativeBootstrap const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &,_IterativeBootstrap const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneForward::PiecewiseConvexMonotoneForward(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneForward_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneForward_dates" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseConvexMonotoneForward const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneForward_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneForward_times" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseConvexMonotoneForward const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneForward_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneForward_nodes" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseConvexMonotoneForward const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneForward_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneForward_recalculate" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneForward_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneForward_freeze" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneForward_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneForward_unfreeze" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseConvexMonotoneForward(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneForward *arg1 = (PiecewiseConvexMonotoneForward *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneForward > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseConvexMonotoneForward" "', argument " "1"" of type '" "PiecewiseConvexMonotoneForward *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneForward > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneForward * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseConvexMonotoneForward_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseConvexMonotoneForward_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  arg6 = reinterpret_cast< ConvexMonotone * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(ConvexMonotone const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  arg6 = reinterpret_cast< ConvexMonotone * >(argp6);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(ConvexMonotone const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  arg7 = reinterpret_cast< ConvexMonotone * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(ConvexMonotone const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  ConvexMonotone *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "7"" of type '" "ConvexMonotone const &""'"); 
  }
  arg7 = reinterpret_cast< ConvexMonotone * >(argp7);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(ConvexMonotone const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  ConvexMonotone *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "ConvexMonotone const &""'"); 
  }
  arg5 = reinterpret_cast< ConvexMonotone * >(argp5);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(ConvexMonotone const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  ConvexMonotone *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_ConvexMonotone,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "6"" of type '" "ConvexMonotone const &""'"); 
  }
  arg6 = reinterpret_cast< ConvexMonotone * >(argp6);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(ConvexMonotone const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseConvexMonotoneZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseConvexMonotoneZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseConvexMonotoneZero *)new_PiecewiseConvexMonotoneZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseConvexMonotoneZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseConvexMonotoneZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseConvexMonotoneZero(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseConvexMonotoneZero", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ConvexMonotone, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseConvexMonotoneZero__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseConvexMonotoneZero'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &,_IterativeBootstrap const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &,_IterativeBootstrap const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,ConvexMonotone const &)\n"
    "    PiecewiseConvexMonotoneZero::PiecewiseConvexMonotoneZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneZero_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneZero_dates" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseConvexMonotoneZero const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneZero_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneZero_times" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseConvexMonotoneZero const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneZero_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneZero_nodes" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseConvexMonotoneZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneZero_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneZero_recalculate" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneZero_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneZero_freeze" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConvexMonotoneZero_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConvexMonotoneZero_unfreeze" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseConvexMonotoneZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConvexMonotoneZero *arg1 = (PiecewiseConvexMonotoneZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > tempshared1 ;
  ext::shared_ptr< PiecewiseConvexMonotoneZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseConvexMonotoneZero" "', argument " "1"" of type '" "PiecewiseConvexMonotoneZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConvexMonotoneZero > * >(argp1);
      arg1 = const_cast< PiecewiseConvexMonotoneZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseConvexMonotoneZero_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseConvexMonotoneZero_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(SplineCubic const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(SplineCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  arg7 = reinterpret_cast< SplineCubic * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(SplineCubic const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  SplineCubic *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "7"" of type '" "SplineCubic const &""'"); 
  }
  arg7 = reinterpret_cast< SplineCubic * >(argp7);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(SplineCubic const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(SplineCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  SplineCubic *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "6"" of type '" "SplineCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineCubic * >(argp6);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(SplineCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseNaturalCubicZero *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalCubicZero" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseNaturalCubicZero *)new_PiecewiseNaturalCubicZero__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalCubicZero > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalCubicZero >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalCubicZero(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseNaturalCubicZero", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseNaturalCubicZero__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseNaturalCubicZero__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseNaturalCubicZero__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseNaturalCubicZero__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalCubicZero__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalCubicZero__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalCubicZero__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalCubicZero__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseNaturalCubicZero__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseNaturalCubicZero__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseNaturalCubicZero__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseNaturalCubicZero__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseNaturalCubicZero__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseNaturalCubicZero__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseNaturalCubicZero'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineCubic const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,SplineCubic const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,SplineCubic const &)\n"
    "    PiecewiseNaturalCubicZero::PiecewiseNaturalCubicZero(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalCubicZero_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalCubicZero_dates" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseNaturalCubicZero const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalCubicZero_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalCubicZero_times" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseNaturalCubicZero const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalCubicZero_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalCubicZero_nodes" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseNaturalCubicZero const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalCubicZero_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalCubicZero_recalculate" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalCubicZero_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalCubicZero_freeze" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalCubicZero_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalCubicZero_unfreeze" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseNaturalCubicZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalCubicZero *arg1 = (PiecewiseNaturalCubicZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalCubicZero > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseNaturalCubicZero" "', argument " "1"" of type '" "PiecewiseNaturalCubicZero *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalCubicZero > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalCubicZero * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseNaturalCubicZero_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseNaturalCubicZero_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  SplineLogCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "SplineLogCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineLogCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(SplineLogCubic const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  SplineLogCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "SplineLogCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineLogCubic * >(argp6);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(SplineLogCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  SplineLogCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "7"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "7"" of type '" "SplineLogCubic const &""'"); 
  }
  arg7 = reinterpret_cast< SplineLogCubic * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(SplineLogCubic const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  SplineLogCubic *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "7"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "7"" of type '" "SplineLogCubic const &""'"); 
  }
  arg7 = reinterpret_cast< SplineLogCubic * >(argp7);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(SplineLogCubic const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  SplineLogCubic *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "SplineLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineLogCubic * >(argp5);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(SplineLogCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  SplineLogCubic *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "6"" of type '" "SplineLogCubic const &""'"); 
  }
  arg6 = reinterpret_cast< SplineLogCubic * >(argp6);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(SplineLogCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseNaturalLogCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseNaturalLogCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseNaturalLogCubicDiscount *)new_PiecewiseNaturalLogCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseNaturalLogCubicDiscount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseNaturalLogCubicDiscount", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseNaturalLogCubicDiscount__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseNaturalLogCubicDiscount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineLogCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineLogCubic const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineLogCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,SplineLogCubic const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,SplineLogCubic const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,SplineLogCubic const &)\n"
    "    PiecewiseNaturalLogCubicDiscount::PiecewiseNaturalLogCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalLogCubicDiscount_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalLogCubicDiscount_dates" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseNaturalLogCubicDiscount const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalLogCubicDiscount_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalLogCubicDiscount_times" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseNaturalLogCubicDiscount const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalLogCubicDiscount_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalLogCubicDiscount_nodes" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseNaturalLogCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalLogCubicDiscount_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalLogCubicDiscount_recalculate" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalLogCubicDiscount_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalLogCubicDiscount_freeze" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseNaturalLogCubicDiscount_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseNaturalLogCubicDiscount_unfreeze" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseNaturalLogCubicDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseNaturalLogCubicDiscount *arg1 = (PiecewiseNaturalLogCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseNaturalLogCubicDiscount" "', argument " "1"" of type '" "PiecewiseNaturalLogCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseNaturalLogCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseNaturalLogCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseNaturalLogCubicDiscount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseNaturalLogCubicDiscount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  LogMixedLinearCubic *arg6 = 0 ;
  _IterativeBootstrap *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg6 = reinterpret_cast< LogMixedLinearCubic * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "7"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg7 = reinterpret_cast< _IterativeBootstrap * >(argp7);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(LogMixedLinearCubic const &)*arg6,(_IterativeBootstrap const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  LogMixedLinearCubic *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg6 = reinterpret_cast< LogMixedLinearCubic * >(argp6);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(LogMixedLinearCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  LogMixedLinearCubic *arg7 = 0 ;
  _IterativeBootstrap *arg8 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "7"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "7"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg7 = reinterpret_cast< LogMixedLinearCubic * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "8"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg8 = reinterpret_cast< _IterativeBootstrap * >(argp8);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(LogMixedLinearCubic const &)*arg7,(_IterativeBootstrap const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  LogMixedLinearCubic *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "7"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "7"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg7 = reinterpret_cast< LogMixedLinearCubic * >(argp7);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(LogMixedLinearCubic const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  LogMixedLinearCubic *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg5 = reinterpret_cast< LogMixedLinearCubic * >(argp5);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4,(LogMixedLinearCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  LogMixedLinearCubic *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "6"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg6 = reinterpret_cast< LogMixedLinearCubic * >(argp6);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5,(LogMixedLinearCubic const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseLogMixedLinearCubicDiscount *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseLogMixedLinearCubicDiscount" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseLogMixedLinearCubicDiscount *)new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > *smartresult = result ? new ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseLogMixedLinearCubicDiscount(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseLogMixedLinearCubicDiscount", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_11(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_10(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_13(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_12(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Date,std::allocator< Date > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_PiecewiseLogMixedLinearCubicDiscount__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseLogMixedLinearCubicDiscount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogMixedLinearCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogMixedLinearCubic const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogMixedLinearCubic const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &,LogMixedLinearCubic const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Date,std::allocator< Date > > const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,LogMixedLinearCubic const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Date const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &,LogMixedLinearCubic const &)\n"
    "    PiecewiseLogMixedLinearCubicDiscount::PiecewiseLogMixedLinearCubicDiscount(Integer,Calendar const &,std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogMixedLinearCubicDiscount_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogMixedLinearCubicDiscount_dates" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseLogMixedLinearCubicDiscount const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogMixedLinearCubicDiscount_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogMixedLinearCubicDiscount_times" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseLogMixedLinearCubicDiscount const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogMixedLinearCubicDiscount_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogMixedLinearCubicDiscount_nodes" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseLogMixedLinearCubicDiscount const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogMixedLinearCubicDiscount_recalculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogMixedLinearCubicDiscount_recalculate" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->recalculate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogMixedLinearCubicDiscount_freeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogMixedLinearCubicDiscount_freeze" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->freeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseLogMixedLinearCubicDiscount_unfreeze(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseLogMixedLinearCubicDiscount_unfreeze" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->unfreeze();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseLogMixedLinearCubicDiscount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseLogMixedLinearCubicDiscount *arg1 = (PiecewiseLogMixedLinearCubicDiscount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > tempshared1 ;
  ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseLogMixedLinearCubicDiscount" "', argument " "1"" of type '" "PiecewiseLogMixedLinearCubicDiscount *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseLogMixedLinearCubicDiscount > * >(argp1);
      arg1 = const_cast< PiecewiseLogMixedLinearCubicDiscount * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseLogMixedLinearCubicDiscount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseLogMixedLinearCubicDiscount_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GlobalBootstrap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  doubleOrNull arg1 ;
  _GlobalBootstrap *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (swig_obj[0] == Py_None)
    arg1 = Null<double>();
    else if (PyFloat_Check(swig_obj[0]))
    arg1 = PyFloat_AsDouble(swig_obj[0]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (_GlobalBootstrap *)new _GlobalBootstrap(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GlobalBootstrap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GlobalBootstrap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  _GlobalBootstrap *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (_GlobalBootstrap *)new _GlobalBootstrap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GlobalBootstrap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GlobalBootstrap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  doubleOrNull arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  _GlobalBootstrap *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GlobalBootstrap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalBootstrap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GlobalBootstrap" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalBootstrap" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    if (swig_obj[2] == Py_None)
    arg3 = Null<double>();
    else if (PyFloat_Check(swig_obj[2]))
    arg3 = PyFloat_AsDouble(swig_obj[2]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (_GlobalBootstrap *)new _GlobalBootstrap((std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GlobalBootstrap, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GlobalBootstrap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  _GlobalBootstrap *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GlobalBootstrap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalBootstrap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GlobalBootstrap" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalBootstrap" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (_GlobalBootstrap *)new _GlobalBootstrap((std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__GlobalBootstrap, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GlobalBootstrap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GlobalBootstrap", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_GlobalBootstrap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      _v = (argv[0] == Py_None || PyFloat_Check(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_GlobalBootstrap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GlobalBootstrap__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = (argv[2] == Py_None || PyFloat_Check(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_GlobalBootstrap__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GlobalBootstrap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    _GlobalBootstrap::_GlobalBootstrap(doubleOrNull)\n"
    "    _GlobalBootstrap::_GlobalBootstrap()\n"
    "    _GlobalBootstrap::_GlobalBootstrap(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,std::vector< Date,std::allocator< Date > > const &,doubleOrNull)\n"
    "    _GlobalBootstrap::_GlobalBootstrap(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &,std::vector< Date,std::allocator< Date > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GlobalBootstrap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _GlobalBootstrap *arg1 = (_GlobalBootstrap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__GlobalBootstrap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GlobalBootstrap" "', argument " "1"" of type '" "_GlobalBootstrap *""'"); 
  }
  arg1 = reinterpret_cast< _GlobalBootstrap * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GlobalBootstrap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__GlobalBootstrap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GlobalBootstrap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GlobalLinearSimpleZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _GlobalBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  GlobalLinearSimpleZeroCurve *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GlobalLinearSimpleZeroCurve", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *ptr = (std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__GlobalBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "4"" of type '" "_GlobalBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GlobalLinearSimpleZeroCurve" "', argument " "4"" of type '" "_GlobalBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _GlobalBootstrap * >(argp4);
  {
    try {
      result = (GlobalLinearSimpleZeroCurve *)new_GlobalLinearSimpleZeroCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< RateHelper >,std::allocator< ext::shared_ptr< RateHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_GlobalBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GlobalLinearSimpleZeroCurve > *smartresult = result ? new ext::shared_ptr<  GlobalLinearSimpleZeroCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalLinearSimpleZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > tempshared1 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalLinearSimpleZeroCurve_dates" "', argument " "1"" of type '" "GlobalLinearSimpleZeroCurve const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((GlobalLinearSimpleZeroCurve const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalLinearSimpleZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > tempshared1 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalLinearSimpleZeroCurve_times" "', argument " "1"" of type '" "GlobalLinearSimpleZeroCurve const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((GlobalLinearSimpleZeroCurve const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GlobalLinearSimpleZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > tempshared1 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GlobalLinearSimpleZeroCurve_nodes" "', argument " "1"" of type '" "GlobalLinearSimpleZeroCurve const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((GlobalLinearSimpleZeroCurve const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GlobalLinearSimpleZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GlobalLinearSimpleZeroCurve *arg1 = (GlobalLinearSimpleZeroCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve > tempshared1 ;
  ext::shared_ptr< GlobalLinearSimpleZeroCurve > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GlobalLinearSimpleZeroCurve" "', argument " "1"" of type '" "GlobalLinearSimpleZeroCurve *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GlobalLinearSimpleZeroCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GlobalLinearSimpleZeroCurve > * >(argp1);
      arg1 = const_cast< GlobalLinearSimpleZeroCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GlobalLinearSimpleZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GlobalLinearSimpleZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(arg1)->defaultProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Probability)(arg1)->defaultProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Probability)(arg1)->defaultProbability(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Probability result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Probability)(arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Probability)(arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Probability result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Probability)(arg1)->defaultProbability(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_defaultProbability" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Probability)(arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructure_defaultProbability", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DefaultProbabilityTermStructure_defaultProbability__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructure_defaultProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &,Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &,Date const &)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time,Time,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time,Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(arg1)->survivalProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Probability)(arg1)->survivalProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(arg1)->survivalProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_survivalProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Probability)(arg1)->survivalProbability(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_survivalProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructure_survivalProbability", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_survivalProbability__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructure_survivalProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Date const &)\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Time,bool)\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->defaultDensity((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)(arg1)->defaultDensity((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->defaultDensity(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_defaultDensity" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(arg1)->defaultDensity(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_defaultDensity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructure_defaultDensity", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_defaultDensity__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructure_defaultDensity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Date const &)\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Time,bool)\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->hazardRate((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)(arg1)->hazardRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(arg1)->hazardRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructure_hazardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(arg1)->hazardRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructure_hazardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructure_hazardRate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructure_hazardRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructure_hazardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::hazardRate(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::hazardRate(Date const &)\n"
    "    DefaultProbabilityTermStructure::hazardRate(Time,bool)\n"
    "    DefaultProbabilityTermStructure::hazardRate(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultProbabilityTermStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityTermStructure *arg1 = (DefaultProbabilityTermStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultProbabilityTermStructure" "', argument " "1"" of type '" "DefaultProbabilityTermStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityTermStructure > * >(argp1);
      arg1 = const_cast< DefaultProbabilityTermStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultProbabilityTermStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DefaultProbabilityTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< DefaultProbabilityTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  Handle< DefaultProbabilityTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultProbabilityTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< DefaultProbabilityTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< DefaultProbabilityTermStructure > *)new Handle< DefaultProbabilityTermStructure >((ext::shared_ptr< DefaultProbabilityTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< DefaultProbabilityTermStructure > *)new Handle< DefaultProbabilityTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DefaultProbabilityTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DefaultProbabilityTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultProbabilityTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DefaultProbabilityTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< DefaultProbabilityTermStructure >::Handle(ext::shared_ptr< DefaultProbabilityTermStructure > const &)\n"
    "    Handle< DefaultProbabilityTermStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< DefaultProbabilityTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle___deref__" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DefaultProbabilityTermStructure > *smartresult = result ? new ext::shared_ptr<  DefaultProbabilityTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< DefaultProbabilityTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DefaultProbabilityTermStructure > *smartresult = result ? new ext::shared_ptr<  DefaultProbabilityTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_DefaultProbabilityTermStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle___bool__" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_DefaultProbabilityTermStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_DefaultProbabilityTermStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefaultProbabilityTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultProbabilityTermStructureHandle" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Probability result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Probability result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_defaultProbability" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Probability)(*arg1)->defaultProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructureHandle_defaultProbability", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_7(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DefaultProbabilityTermStructureHandle_defaultProbability__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructureHandle_defaultProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &,Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Date const &,Date const &)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time,Time,bool)\n"
    "    DefaultProbabilityTermStructure::defaultProbability(Time,Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(*arg1)->survivalProbability((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Probability)(*arg1)->survivalProbability((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Probability result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Probability)(*arg1)->survivalProbability(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Probability result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_survivalProbability" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Probability)(*arg1)->survivalProbability(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_survivalProbability(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructureHandle_survivalProbability", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_survivalProbability__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructureHandle_survivalProbability'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Date const &)\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Time,bool)\n"
    "    DefaultProbabilityTermStructure::survivalProbability(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(*arg1)->defaultDensity((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)(*arg1)->defaultDensity((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(*arg1)->defaultDensity(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_defaultDensity" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(*arg1)->defaultDensity(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_defaultDensity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructureHandle_defaultDensity", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_defaultDensity__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructureHandle_defaultDensity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Date const &)\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Time,bool)\n"
    "    DefaultProbabilityTermStructure::defaultDensity(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(*arg1)->hazardRate((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)(*arg1)->hazardRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (Real)(*arg1)->hazardRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityTermStructureHandle_hazardRate" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(*arg1)->hazardRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_hazardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructureHandle_hazardRate", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityTermStructureHandle_hazardRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityTermStructureHandle_hazardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DefaultProbabilityTermStructure::hazardRate(Date const &,bool)\n"
    "    DefaultProbabilityTermStructure::hazardRate(Date const &)\n"
    "    DefaultProbabilityTermStructure::hazardRate(Time,bool)\n"
    "    DefaultProbabilityTermStructure::hazardRate(Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityTermStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityTermStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_calendar" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityTermStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = (Handle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityTermStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultProbabilityTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DefaultProbabilityTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableDefaultProbabilityTermStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< DefaultProbabilityTermStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared1 ;
  RelinkableHandle< DefaultProbabilityTermStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableDefaultProbabilityTermStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< DefaultProbabilityTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< DefaultProbabilityTermStructure > *)new RelinkableHandle< DefaultProbabilityTermStructure >((ext::shared_ptr< DefaultProbabilityTermStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableDefaultProbabilityTermStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< DefaultProbabilityTermStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< DefaultProbabilityTermStructure > *)new RelinkableHandle< DefaultProbabilityTermStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableDefaultProbabilityTermStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableDefaultProbabilityTermStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableDefaultProbabilityTermStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableDefaultProbabilityTermStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableDefaultProbabilityTermStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< DefaultProbabilityTermStructure >::RelinkableHandle(ext::shared_ptr< DefaultProbabilityTermStructure > const &)\n"
    "    RelinkableHandle< DefaultProbabilityTermStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableDefaultProbabilityTermStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< DefaultProbabilityTermStructure > *arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *) 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< DefaultProbabilityTermStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableDefaultProbabilityTermStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableDefaultProbabilityTermStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< DefaultProbabilityTermStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableDefaultProbabilityTermStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< DefaultProbabilityTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< DefaultProbabilityTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< DefaultProbabilityTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableDefaultProbabilityTermStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< DefaultProbabilityTermStructure > *arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableDefaultProbabilityTermStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_DefaultProbabilityTermStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableDefaultProbabilityTermStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< DefaultProbabilityTermStructure > *arg1 = (RelinkableHandle< DefaultProbabilityTermStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableDefaultProbabilityTermStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< DefaultProbabilityTermStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< DefaultProbabilityTermStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableDefaultProbabilityTermStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_DefaultProbabilityTermStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableDefaultProbabilityTermStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FlatHazardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FlatHazardRate *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlatHazardRate" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatHazardRate" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatHazardRate" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (FlatHazardRate *)new FlatHazardRate(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatHazardRate > *smartresult = result ? new ext::shared_ptr<  FlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatHazardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FlatHazardRate *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FlatHazardRate" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatHazardRate" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (FlatHazardRate *)new FlatHazardRate((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FlatHazardRate > *smartresult = result ? new ext::shared_ptr<  FlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlatHazardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FlatHazardRate", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FlatHazardRate__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FlatHazardRate__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FlatHazardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FlatHazardRate::FlatHazardRate(Integer,Calendar const &,Handle< Quote > const &,DayCounter const &)\n"
    "    FlatHazardRate::FlatHazardRate(Date const &,Handle< Quote > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FlatHazardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FlatHazardRate *arg1 = (FlatHazardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FlatHazardRate > tempshared1 ;
  ext::shared_ptr< FlatHazardRate > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FlatHazardRate_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlatHazardRate" "', argument " "1"" of type '" "FlatHazardRate *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FlatHazardRate > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FlatHazardRate > * >(argp1);
      arg1 = const_cast< FlatHazardRate * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FlatHazardRate > * >(argp1);
      arg1 = const_cast< FlatHazardRate * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FlatHazardRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FlatHazardRate_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FlatHazardRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HazardRateCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedHazardRateCurve< BackwardFlat > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HazardRateCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HazardRateCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HazardRateCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HazardRateCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_HazardRateCurve" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  arg5 = reinterpret_cast< BackwardFlat * >(argp5);
  {
    try {
      result = (InterpolatedHazardRateCurve< BackwardFlat > *)new InterpolatedHazardRateCurve< BackwardFlat >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HazardRateCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedHazardRateCurve< BackwardFlat > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HazardRateCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HazardRateCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HazardRateCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HazardRateCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedHazardRateCurve< BackwardFlat > *)new InterpolatedHazardRateCurve< BackwardFlat >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HazardRateCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedHazardRateCurve< BackwardFlat > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HazardRateCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HazardRateCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HazardRateCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HazardRateCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedHazardRateCurve< BackwardFlat > *)new InterpolatedHazardRateCurve< BackwardFlat >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HazardRateCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HazardRateCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_HazardRateCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_HazardRateCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_HazardRateCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HazardRateCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedHazardRateCurve< BackwardFlat >::InterpolatedHazardRateCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Calendar const &,BackwardFlat const &)\n"
    "    InterpolatedHazardRateCurve< BackwardFlat >::InterpolatedHazardRateCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedHazardRateCurve< BackwardFlat >::InterpolatedHazardRateCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HazardRateCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > tempshared1 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HazardRateCurve_dates" "', argument " "1"" of type '" "InterpolatedHazardRateCurve< BackwardFlat > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedHazardRateCurve< BackwardFlat > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HazardRateCurve_hazardRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > tempshared1 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HazardRateCurve_hazardRates" "', argument " "1"" of type '" "InterpolatedHazardRateCurve< BackwardFlat > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedHazardRateCurve< BackwardFlat > const *)arg1)->hazardRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HazardRateCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > tempshared1 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HazardRateCurve_nodes" "', argument " "1"" of type '" "InterpolatedHazardRateCurve< BackwardFlat > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedHazardRateCurve< BackwardFlat > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HazardRateCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedHazardRateCurve< BackwardFlat > *arg1 = (InterpolatedHazardRateCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > tempshared1 ;
  ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HazardRateCurve" "', argument " "1"" of type '" "InterpolatedHazardRateCurve< BackwardFlat > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedHazardRateCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedHazardRateCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HazardRateCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HazardRateCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DefaultDensityCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDefaultDensityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultDensityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DefaultDensityCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DefaultDensityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DefaultDensityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DefaultDensityCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (InterpolatedDefaultDensityCurve< Linear > *)new InterpolatedDefaultDensityCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultDensityCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDefaultDensityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultDensityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DefaultDensityCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DefaultDensityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DefaultDensityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDefaultDensityCurve< Linear > *)new InterpolatedDefaultDensityCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultDensityCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDefaultDensityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultDensityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DefaultDensityCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DefaultDensityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultDensityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDefaultDensityCurve< Linear > *)new InterpolatedDefaultDensityCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Real,std::allocator< Real > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultDensityCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DefaultDensityCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_DefaultDensityCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_DefaultDensityCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_DefaultDensityCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DefaultDensityCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDefaultDensityCurve< Linear >::InterpolatedDefaultDensityCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Calendar const &,Linear const &)\n"
    "    InterpolatedDefaultDensityCurve< Linear >::InterpolatedDefaultDensityCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDefaultDensityCurve< Linear >::InterpolatedDefaultDensityCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultDensityCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultDensityCurve_dates" "', argument " "1"" of type '" "InterpolatedDefaultDensityCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDefaultDensityCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultDensityCurve_defaultDensities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultDensityCurve_defaultDensities" "', argument " "1"" of type '" "InterpolatedDefaultDensityCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDefaultDensityCurve< Linear > const *)arg1)->defaultDensities();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultDensityCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultDensityCurve_nodes" "', argument " "1"" of type '" "InterpolatedDefaultDensityCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDefaultDensityCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefaultDensityCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDefaultDensityCurve< Linear > *arg1 = (InterpolatedDefaultDensityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultDensityCurve" "', argument " "1"" of type '" "InterpolatedDefaultDensityCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDefaultDensityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedDefaultDensityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultDensityCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DefaultDensityCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SurvivalProbabilityCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Probability,std::allocator< Probability > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedSurvivalProbabilityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SurvivalProbabilityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SurvivalProbabilityCurve" "', argument " "2"" of type '" "std::vector< Probability,std::allocator< Probability > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "2"" of type '" "std::vector< Probability,std::allocator< Probability > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SurvivalProbabilityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SurvivalProbabilityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_SurvivalProbabilityCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (InterpolatedSurvivalProbabilityCurve< Linear > *)new InterpolatedSurvivalProbabilityCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Probability,std::allocator< Probability > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SurvivalProbabilityCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Probability,std::allocator< Probability > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedSurvivalProbabilityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SurvivalProbabilityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SurvivalProbabilityCurve" "', argument " "2"" of type '" "std::vector< Probability,std::allocator< Probability > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "2"" of type '" "std::vector< Probability,std::allocator< Probability > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SurvivalProbabilityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SurvivalProbabilityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedSurvivalProbabilityCurve< Linear > *)new InterpolatedSurvivalProbabilityCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Probability,std::allocator< Probability > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SurvivalProbabilityCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Probability,std::allocator< Probability > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedSurvivalProbabilityCurve< Linear > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SurvivalProbabilityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SurvivalProbabilityCurve" "', argument " "2"" of type '" "std::vector< Probability,std::allocator< Probability > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "2"" of type '" "std::vector< Probability,std::allocator< Probability > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SurvivalProbabilityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SurvivalProbabilityCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedSurvivalProbabilityCurve< Linear > *)new InterpolatedSurvivalProbabilityCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Probability,std::allocator< Probability > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SurvivalProbabilityCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SurvivalProbabilityCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SurvivalProbabilityCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SurvivalProbabilityCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_SurvivalProbabilityCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SurvivalProbabilityCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedSurvivalProbabilityCurve< Linear >::InterpolatedSurvivalProbabilityCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Probability,std::allocator< Probability > > const &,DayCounter const &,Calendar const &,Linear const &)\n"
    "    InterpolatedSurvivalProbabilityCurve< Linear >::InterpolatedSurvivalProbabilityCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Probability,std::allocator< Probability > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedSurvivalProbabilityCurve< Linear >::InterpolatedSurvivalProbabilityCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Probability,std::allocator< Probability > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SurvivalProbabilityCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SurvivalProbabilityCurve_dates" "', argument " "1"" of type '" "InterpolatedSurvivalProbabilityCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedSurvivalProbabilityCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SurvivalProbabilityCurve_survivalProbabilities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Probability,std::allocator< Probability > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SurvivalProbabilityCurve_survivalProbabilities" "', argument " "1"" of type '" "InterpolatedSurvivalProbabilityCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Probability,std::allocator< Probability > > *) &((InterpolatedSurvivalProbabilityCurve< Linear > const *)arg1)->survivalProbabilities();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SurvivalProbabilityCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SurvivalProbabilityCurve_nodes" "', argument " "1"" of type '" "InterpolatedSurvivalProbabilityCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedSurvivalProbabilityCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SurvivalProbabilityCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedSurvivalProbabilityCurve< Linear > *arg1 = (InterpolatedSurvivalProbabilityCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SurvivalProbabilityCurve" "', argument " "1"" of type '" "InterpolatedSurvivalProbabilityCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedSurvivalProbabilityCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedSurvivalProbabilityCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SurvivalProbabilityCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SurvivalProbabilityCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_quote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_quote" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->quote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_latestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_latestDate" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->latestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_earliestDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_earliestDate" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->earliestDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_maturityDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_maturityDate" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->maturityDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_latestRelevantDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_latestRelevantDate" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->latestRelevantDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_pillarDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_pillarDate" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((DefaultProbabilityHelper const *)arg1)->pillarDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_impliedQuote(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_impliedQuote" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((DefaultProbabilityHelper const *)arg1)->impliedQuote();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelper_quoteError(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper const > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelper_quoteError" "', argument " "1"" of type '" "DefaultProbabilityHelper const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((DefaultProbabilityHelper const *)arg1)->quoteError();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefaultProbabilityHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultProbabilityHelper *arg1 = (DefaultProbabilityHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultProbabilityHelper > tempshared1 ;
  ext::shared_ptr< DefaultProbabilityHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultProbabilityHelper" "', argument " "1"" of type '" "DefaultProbabilityHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultProbabilityHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultProbabilityHelper > * >(argp1);
      arg1 = const_cast< DefaultProbabilityHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultProbabilityHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____bool__((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____len__((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityHelperVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityHelperVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DefaultProbabilityHelperVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DefaultProbabilityHelperVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__setslice__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__setslice__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityHelperVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__delitem__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DefaultProbabilityHelper > *smartresult = *result ? new ext::shared_ptr<  DefaultProbabilityHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__getitem__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityHelperVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< DefaultProbabilityHelper > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DefaultProbabilityHelperVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DefaultProbabilityHelperVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::__setitem__(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DefaultProbabilityHelper > *smartresult = result ? new ext::shared_ptr<  DefaultProbabilityHelper >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityHelperVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__append(arg1,(ext::shared_ptr< DefaultProbabilityHelper > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityHelperVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityHelperVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultProbabilityHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultProbabilityHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DefaultProbabilityHelperVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityHelperVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DefaultProbabilityHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DefaultProbabilityHelperVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::erase(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::erase(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityHelperVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg1 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DefaultProbabilityHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DefaultProbabilityHelperVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *)new std::vector< ext::shared_ptr< DefaultProbabilityHelper > >(arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultProbabilityHelperVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DefaultProbabilityHelperVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DefaultProbabilityHelperVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DefaultProbabilityHelperVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultProbabilityHelperVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DefaultProbabilityHelperVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DefaultProbabilityHelperVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::vector()\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::vector(std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const &)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::vector(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::vector(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DefaultProbabilityHelperVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *) &((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DefaultProbabilityHelper > *smartresult = *result ? new ext::shared_ptr<  DefaultProbabilityHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *) &((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DefaultProbabilityHelper > *smartresult = *result ? new ext::shared_ptr<  DefaultProbabilityHelper >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityHelperVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityHelperVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DefaultProbabilityHelperVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DefaultProbabilityHelperVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::resize(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::resize(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< DefaultProbabilityHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator arg2 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg3 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DefaultProbabilityHelperVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_DefaultProbabilityHelper_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< DefaultProbabilityHelper > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DefaultProbabilityHelperVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_DefaultProbabilityHelper_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DefaultProbabilityHelperVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DefaultProbabilityHelperVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::insert(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::insert(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type,std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DefaultProbabilityHelperVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DefaultProbabilityHelperVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DefaultProbabilityHelperVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DefaultProbabilityHelperVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< DefaultProbabilityHelper > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefaultProbabilityHelperVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *arg1 = (std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultProbabilityHelperVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< DefaultProbabilityHelper > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultProbabilityHelperVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_DefaultProbabilityHelper_t_std__allocatorT_ext__shared_ptrT_DefaultProbabilityHelper_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DefaultProbabilityHelperVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  CreditDefaultSwap::PricingModel arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  arg14 = reinterpret_cast< DayCounter * >(argp14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SpreadCdsHelper" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_int(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SpreadCdsHelper" "', argument " "16"" of type '" "CreditDefaultSwap::PricingModel""'");
  } 
  arg16 = static_cast< CreditDefaultSwap::PricingModel >(val16);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  arg14 = reinterpret_cast< DayCounter * >(argp14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SpreadCdsHelper" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  arg14 = reinterpret_cast< DayCounter * >(argp14);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper((Handle< Quote > const &)*arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  CreditDefaultSwap::PricingModel arg16 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  arg14 = reinterpret_cast< DayCounter * >(argp14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SpreadCdsHelper" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_int(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_SpreadCdsHelper" "', argument " "16"" of type '" "CreditDefaultSwap::PricingModel""'");
  } 
  arg16 = static_cast< CreditDefaultSwap::PricingModel >(val16);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*arg14,arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  bool arg15 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  arg14 = reinterpret_cast< DayCounter * >(argp14);
  ecode15 = SWIG_AsVal_bool(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_SpreadCdsHelper" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*arg14,arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  DayCounter *arg14 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[13], &argp14, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "14"" of type '" "DayCounter const &""'"); 
  }
  arg14 = reinterpret_cast< DayCounter * >(argp14);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13,(DayCounter const &)*arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  bool arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpreadCdsHelper" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  bool arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  ecode11 = SWIG_AsVal_bool(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpreadCdsHelper" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Period *arg2 = 0 ;
  Integer arg3 ;
  Calendar *arg4 = 0 ;
  Frequency arg5 ;
  BusinessDayConvention arg6 ;
  DateGeneration::Rule arg7 ;
  DayCounter *arg8 = 0 ;
  Real arg9 ;
  Handle< YieldTermStructure > *arg10 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  SpreadCdsHelper *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpreadCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadCdsHelper" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpreadCdsHelper" "', argument " "5"" of type '" "Frequency""'");
  } 
  arg5 = static_cast< Frequency >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpreadCdsHelper" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpreadCdsHelper" "', argument " "7"" of type '" "DateGeneration::Rule""'");
  } 
  arg7 = static_cast< DateGeneration::Rule >(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "8"" of type '" "DayCounter const &""'"); 
  }
  arg8 = reinterpret_cast< DayCounter * >(argp8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpreadCdsHelper" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadCdsHelper" "', argument " "10"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg10 = reinterpret_cast< Handle< YieldTermStructure > * >(argp10);
  {
    try {
      result = (SpreadCdsHelper *)new SpreadCdsHelper(arg1,(Period const &)*arg2,arg3,(Calendar const &)*arg4,arg5,arg6,arg7,(DayCounter const &)*arg8,arg9,(Handle< YieldTermStructure > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadCdsHelper > *smartresult = result ? new ext::shared_ptr<  SpreadCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadCdsHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[17] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpreadCdsHelper", 0, 16, argv))) SWIG_fail;
  --argc;
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_SpreadCdsHelper__SWIG_6(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_SpreadCdsHelper__SWIG_13(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SpreadCdsHelper__SWIG_5(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SpreadCdsHelper__SWIG_12(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SpreadCdsHelper__SWIG_4(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SpreadCdsHelper__SWIG_11(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_SpreadCdsHelper__SWIG_3(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_SpreadCdsHelper__SWIG_10(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_SpreadCdsHelper__SWIG_2(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_new_SpreadCdsHelper__SWIG_9(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_SpreadCdsHelper__SWIG_1(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_SpreadCdsHelper__SWIG_8(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SpreadCdsHelper__SWIG_0(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              int res = SWIG_ConvertPtr(argv[13], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_SpreadCdsHelper__SWIG_7(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SpreadCdsHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &,DayCounter const &,bool,CreditDefaultSwap::PricingModel)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &,DayCounter const &,bool)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &,DayCounter const &)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Handle< Quote > const &,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &,DayCounter const &,bool,CreditDefaultSwap::PricingModel)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &,DayCounter const &,bool)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &,DayCounter const &)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool,Date const &)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool,bool)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,bool)\n"
    "    SpreadCdsHelper::SpreadCdsHelper(Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SpreadCdsHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SpreadCdsHelper *arg1 = (SpreadCdsHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SpreadCdsHelper > tempshared1 ;
  ext::shared_ptr< SpreadCdsHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadCdsHelper" "', argument " "1"" of type '" "SpreadCdsHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SpreadCdsHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SpreadCdsHelper > * >(argp1);
      arg1 = const_cast< SpreadCdsHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SpreadCdsHelper > * >(argp1);
      arg1 = const_cast< SpreadCdsHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadCdsHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SpreadCdsHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpreadCdsHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  CreditDefaultSwap::PricingModel arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  arg16 = reinterpret_cast< DayCounter * >(argp16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_UpfrontCdsHelper" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_int(swig_obj[17], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_UpfrontCdsHelper" "', argument " "18"" of type '" "CreditDefaultSwap::PricingModel""'");
  } 
  arg18 = static_cast< CreditDefaultSwap::PricingModel >(val18);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  arg16 = reinterpret_cast< DayCounter * >(argp16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_UpfrontCdsHelper" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  arg16 = reinterpret_cast< DayCounter * >(argp16);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper((Handle< Quote > const &)*arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  CreditDefaultSwap::PricingModel arg18 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 18) || (nobjs > 18)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  arg16 = reinterpret_cast< DayCounter * >(argp16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_UpfrontCdsHelper" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_int(swig_obj[17], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_UpfrontCdsHelper" "', argument " "18"" of type '" "CreditDefaultSwap::PricingModel""'");
  } 
  arg18 = static_cast< CreditDefaultSwap::PricingModel >(val18);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16,arg17,arg18);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  bool arg17 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 17) || (nobjs > 17)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  arg16 = reinterpret_cast< DayCounter * >(argp16);
  ecode17 = SWIG_AsVal_bool(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_UpfrontCdsHelper" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16,arg17);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  DayCounter *arg16 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  res16 = SWIG_ConvertPtr(swig_obj[15], &argp16, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  if (!argp16) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "16"" of type '" "DayCounter const &""'"); 
  }
  arg16 = reinterpret_cast< DayCounter * >(argp16);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15,(DayCounter const &)*arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  bool arg14 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_UpfrontCdsHelper" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  bool arg13 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_UpfrontCdsHelper" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  Natural arg12 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_UpfrontCdsHelper" "', argument " "12"" of type '" "Natural""'");
  } 
  arg12 = static_cast< Natural >(val12);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Rate arg1 ;
  Rate arg2 ;
  Period *arg3 = 0 ;
  Integer arg4 ;
  Calendar *arg5 = 0 ;
  Frequency arg6 ;
  BusinessDayConvention arg7 ;
  DateGeneration::Rule arg8 ;
  DayCounter *arg9 = 0 ;
  Real arg10 ;
  Handle< YieldTermStructure > *arg11 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  UpfrontCdsHelper *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpfrontCdsHelper" "', argument " "1"" of type '" "Rate""'");
  } 
  arg1 = static_cast< Rate >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UpfrontCdsHelper" "', argument " "2"" of type '" "Rate""'");
  } 
  arg2 = static_cast< Rate >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_UpfrontCdsHelper" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "5"" of type '" "Calendar const &""'"); 
  }
  arg5 = reinterpret_cast< Calendar * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_UpfrontCdsHelper" "', argument " "6"" of type '" "Frequency""'");
  } 
  arg6 = static_cast< Frequency >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_UpfrontCdsHelper" "', argument " "7"" of type '" "BusinessDayConvention""'");
  } 
  arg7 = static_cast< BusinessDayConvention >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_UpfrontCdsHelper" "', argument " "8"" of type '" "DateGeneration::Rule""'");
  } 
  arg8 = static_cast< DateGeneration::Rule >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "9"" of type '" "DayCounter const &""'"); 
  }
  arg9 = reinterpret_cast< DayCounter * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_UpfrontCdsHelper" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UpfrontCdsHelper" "', argument " "11"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg11 = reinterpret_cast< Handle< YieldTermStructure > * >(argp11);
  {
    try {
      result = (UpfrontCdsHelper *)new UpfrontCdsHelper(arg1,arg2,(Period const &)*arg3,arg4,(Calendar const &)*arg5,arg6,arg7,arg8,(DayCounter const &)*arg9,arg10,(Handle< YieldTermStructure > const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  UpfrontCdsHelper > *smartresult = result ? new ext::shared_ptr<  UpfrontCdsHelper >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UpfrontCdsHelper(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[19] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UpfrontCdsHelper", 0, 18, argv))) SWIG_fail;
  --argc;
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_UpfrontCdsHelper__SWIG_7(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_UpfrontCdsHelper__SWIG_15(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_UpfrontCdsHelper__SWIG_6(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_UpfrontCdsHelper__SWIG_14(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_UpfrontCdsHelper__SWIG_5(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_UpfrontCdsHelper__SWIG_13(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_UpfrontCdsHelper__SWIG_4(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_UpfrontCdsHelper__SWIG_12(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_UpfrontCdsHelper__SWIG_3(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_UpfrontCdsHelper__SWIG_11(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_UpfrontCdsHelper__SWIG_2(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_new_UpfrontCdsHelper__SWIG_10(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_UpfrontCdsHelper__SWIG_1(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_UpfrontCdsHelper__SWIG_9(self, argc, argv);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_new_UpfrontCdsHelper__SWIG_0(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  int res = SWIG_ConvertPtr(argv[15], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_int(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_new_UpfrontCdsHelper__SWIG_8(self, argc, argv);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UpfrontCdsHelper'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &,DayCounter const &,bool,CreditDefaultSwap::PricingModel)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &,DayCounter const &,bool)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &,DayCounter const &)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Handle< Quote > const &,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &,DayCounter const &,bool,CreditDefaultSwap::PricingModel)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &,DayCounter const &,bool)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &,DayCounter const &)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool,Date const &)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool,bool)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural,bool)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &,Natural)\n"
    "    UpfrontCdsHelper::UpfrontCdsHelper(Rate,Rate,Period const &,Integer,Calendar const &,Frequency,BusinessDayConvention,DateGeneration::Rule,DayCounter const &,Real,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UpfrontCdsHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UpfrontCdsHelper *arg1 = (UpfrontCdsHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< UpfrontCdsHelper > tempshared1 ;
  ext::shared_ptr< UpfrontCdsHelper > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UpfrontCdsHelper" "', argument " "1"" of type '" "UpfrontCdsHelper *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  UpfrontCdsHelper > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  UpfrontCdsHelper > * >(argp1);
      arg1 = const_cast< UpfrontCdsHelper * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  UpfrontCdsHelper > * >(argp1);
      arg1 = const_cast< UpfrontCdsHelper * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UpfrontCdsHelper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_UpfrontCdsHelper_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UpfrontCdsHelper_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HazardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HazardRate *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HazardRate", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (HazardRate *)new HazardRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HazardRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HazardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HazardRate *arg1 = (HazardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HazardRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HazardRate" "', argument " "1"" of type '" "HazardRate *""'"); 
  }
  arg1 = reinterpret_cast< HazardRate * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HazardRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HazardRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HazardRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DefaultDensity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultDensity *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DefaultDensity", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (DefaultDensity *)new DefaultDensity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DefaultDensity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DefaultDensity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultDensity *arg1 = (DefaultDensity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DefaultDensity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultDensity" "', argument " "1"" of type '" "DefaultDensity *""'"); 
  }
  arg1 = reinterpret_cast< DefaultDensity * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultDensity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DefaultDensity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DefaultDensity_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BackwardFlat *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "BackwardFlat const &""'"); 
  }
  arg4 = reinterpret_cast< BackwardFlat * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg2,(DayCounter const &)*arg3,(BackwardFlat const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  BackwardFlat *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "BackwardFlat const &""'"); 
  }
  arg4 = reinterpret_cast< BackwardFlat * >(argp4);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg2,(DayCounter const &)*arg3,(BackwardFlat const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_0((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  _IterativeBootstrap *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  arg5 = reinterpret_cast< BackwardFlat * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "6"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "6"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg6 = reinterpret_cast< _IterativeBootstrap * >(argp6);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3,(DayCounter const &)*arg4,(BackwardFlat const &)*arg5,(_IterativeBootstrap const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  arg5 = reinterpret_cast< BackwardFlat * >(argp5);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3,(DayCounter const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_3(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  _IterativeBootstrap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg4 = reinterpret_cast< _IterativeBootstrap * >(argp4);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_6((Date const &)*arg1,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg2,(DayCounter const &)*arg3,(_IterativeBootstrap const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  _IterativeBootstrap *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PiecewiseFlatHazardRate *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *ptr = (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p__IterativeBootstrap,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PiecewiseFlatHazardRate" "', argument " "5"" of type '" "_IterativeBootstrap const &""'"); 
  }
  arg5 = reinterpret_cast< _IterativeBootstrap * >(argp5);
  {
    try {
      result = (PiecewiseFlatHazardRate *)new_PiecewiseFlatHazardRate__SWIG_7(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &)*arg3,(DayCounter const &)*arg4,(_IterativeBootstrap const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  PiecewiseFlatHazardRate > *smartresult = result ? new ext::shared_ptr<  PiecewiseFlatHazardRate >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PiecewiseFlatHazardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PiecewiseFlatHazardRate", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PiecewiseFlatHazardRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseFlatHazardRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseFlatHazardRate__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PiecewiseFlatHazardRate__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatHazardRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatHazardRate__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PiecewiseFlatHazardRate__SWIG_7(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p__IterativeBootstrap, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_PiecewiseFlatHazardRate__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PiecewiseFlatHazardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Date const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,BackwardFlat const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Date const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,BackwardFlat const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Date const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Integer,Calendar const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,BackwardFlat const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Integer,Calendar const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,BackwardFlat const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Integer,Calendar const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Date const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n"
    "    PiecewiseFlatHazardRate::PiecewiseFlatHazardRate(Integer,Calendar const &,std::vector< ext::shared_ptr< DefaultProbabilityHelper >,std::allocator< ext::shared_ptr< DefaultProbabilityHelper > > > const &,DayCounter const &,_IterativeBootstrap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatHazardRate_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatHazardRate_dates" "', argument " "1"" of type '" "PiecewiseFlatHazardRate const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((PiecewiseFlatHazardRate const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatHazardRate_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatHazardRate_times" "', argument " "1"" of type '" "PiecewiseFlatHazardRate const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseFlatHazardRate const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseFlatHazardRate_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatHazardRate const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Real >,std::allocator< std::pair< Date,Real > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseFlatHazardRate_nodes" "', argument " "1"" of type '" "PiecewiseFlatHazardRate const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseFlatHazardRate const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseFlatHazardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseFlatHazardRate *arg1 = (PiecewiseFlatHazardRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseFlatHazardRate > tempshared1 ;
  ext::shared_ptr< PiecewiseFlatHazardRate > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseFlatHazardRate" "', argument " "1"" of type '" "PiecewiseFlatHazardRate *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseFlatHazardRate > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseFlatHazardRate > * >(argp1);
      arg1 = const_cast< PiecewiseFlatHazardRate * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseFlatHazardRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseFlatHazardRate_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PiecewiseFlatHazardRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RiskyBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  RiskyBondEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RiskyBondEngine", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RiskyBondEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskyBondEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RiskyBondEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RiskyBondEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskyBondEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (RiskyBondEngine *)new RiskyBondEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  RiskyBondEngine > *smartresult = result ? new ext::shared_ptr<  RiskyBondEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_RiskyBondEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RiskyBondEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskyBondEngine *arg1 = (RiskyBondEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RiskyBondEngine > tempshared1 ;
  ext::shared_ptr< RiskyBondEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RiskyBondEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RiskyBondEngine" "', argument " "1"" of type '" "RiskyBondEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  RiskyBondEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  RiskyBondEngine > * >(argp1);
      arg1 = const_cast< RiskyBondEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  RiskyBondEngine > * >(argp1);
      arg1 = const_cast< RiskyBondEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RiskyBondEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_RiskyBondEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RiskyBondEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Protection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Protection *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Protection", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Protection *)new Protection();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Protection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Protection(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Protection *arg1 = (Protection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Protection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Protection" "', argument " "1"" of type '" "Protection *""'"); 
  }
  arg1 = reinterpret_cast< Protection * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Protection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Protection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Protection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Claim_amount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Claim *arg1 = (Claim *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Claim const > tempshared1 ;
  ext::shared_ptr< Claim const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Claim_amount", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Claim_amount" "', argument " "1"" of type '" "Claim const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Claim > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Claim > * >(argp1);
      arg1 = const_cast< Claim * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Claim > * >(argp1);
      arg1 = const_cast< Claim * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Claim_amount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Claim_amount" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Claim_amount" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Claim_amount" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((Claim const *)arg1)->amount((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Claim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Claim *arg1 = (Claim *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Claim > tempshared1 ;
  ext::shared_ptr< Claim > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Claim" "', argument " "1"" of type '" "Claim *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Claim > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Claim > * >(argp1);
      arg1 = const_cast< Claim * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Claim > * >(argp1);
      arg1 = const_cast< Claim * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Claim_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Claim_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FaceValueClaim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FaceValueClaim *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FaceValueClaim", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (FaceValueClaim *)new FaceValueClaim();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FaceValueClaim > *smartresult = result ? new ext::shared_ptr<  FaceValueClaim >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FaceValueClaim_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FaceValueClaim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FaceValueClaim *arg1 = (FaceValueClaim *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FaceValueClaim > tempshared1 ;
  ext::shared_ptr< FaceValueClaim > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FaceValueClaim_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FaceValueClaim" "', argument " "1"" of type '" "FaceValueClaim *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FaceValueClaim > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FaceValueClaim > * >(argp1);
      arg1 = const_cast< FaceValueClaim * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FaceValueClaim > * >(argp1);
      arg1 = const_cast< FaceValueClaim * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FaceValueClaim_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FaceValueClaim_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FaceValueClaim_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FaceValueAccrualClaim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Bond > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Bond > tempshared1 ;
  PyObject *swig_obj[1] ;
  FaceValueAccrualClaim *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Bond_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FaceValueAccrualClaim" "', argument " "1"" of type '" "ext::shared_ptr< Bond > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Bond > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Bond > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Bond > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FaceValueAccrualClaim *)new FaceValueAccrualClaim((ext::shared_ptr< Bond > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FaceValueAccrualClaim > *smartresult = result ? new ext::shared_ptr<  FaceValueAccrualClaim >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FaceValueAccrualClaim_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FaceValueAccrualClaim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FaceValueAccrualClaim *arg1 = (FaceValueAccrualClaim *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FaceValueAccrualClaim > tempshared1 ;
  ext::shared_ptr< FaceValueAccrualClaim > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FaceValueAccrualClaim_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FaceValueAccrualClaim" "', argument " "1"" of type '" "FaceValueAccrualClaim *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FaceValueAccrualClaim > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FaceValueAccrualClaim > * >(argp1);
      arg1 = const_cast< FaceValueAccrualClaim * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FaceValueAccrualClaim > * >(argp1);
      arg1 = const_cast< FaceValueAccrualClaim * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FaceValueAccrualClaim_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FaceValueAccrualClaim_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FaceValueAccrualClaim_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  Natural arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< Claim > tempshared10 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  unsigned int val14 ;
  int ecode14 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp10) : &tempshared10;
    }
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  ecode14 = SWIG_AsVal_unsigned_SS_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CreditDefaultSwap" "', argument " "14"" of type '" "Natural""'");
  } 
  arg14 = static_cast< Natural >(val14);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10,(DayCounter const &)*arg11,arg12,(Date const &)*arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  Date *arg13 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< Claim > tempshared10 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp10) : &tempshared10;
    }
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "Date const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "Date const &""'"); 
  }
  arg13 = reinterpret_cast< Date * >(argp13);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10,(DayCounter const &)*arg11,arg12,(Date const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  bool arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< Claim > tempshared10 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp10) : &tempshared10;
    }
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10,(DayCounter const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  DayCounter *arg11 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< Claim > tempshared10 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp10) : &tempshared10;
    }
  }
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "DayCounter const &""'"); 
  }
  arg11 = reinterpret_cast< DayCounter * >(argp11);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10,(DayCounter const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  ext::shared_ptr< Claim > *arg10 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  ext::shared_ptr< Claim > tempshared10 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    int newmem = 0;
    res10 = SWIG_ConvertPtrAndOwn(swig_obj[9], &argp10, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp10) tempshared10 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp10);
      arg10 = &tempshared10;
    } else {
      arg10 = (argp10) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp10) : &tempshared10;
    }
  }
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9,(ext::shared_ptr< Claim > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  Date *arg9 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "Date const &""'"); 
  }
  arg9 = reinterpret_cast< Date * >(argp9);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8,(Date const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  bool arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Schedule *arg4 = 0 ;
  BusinessDayConvention arg5 ;
  DayCounter *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Schedule const &""'"); 
  }
  arg4 = reinterpret_cast< Schedule * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "BusinessDayConvention""'");
  } 
  arg5 = static_cast< BusinessDayConvention >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,(Schedule const &)*arg4,arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  Natural arg16 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< Claim > tempshared12 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  unsigned int val16 ;
  int ecode16 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 16) || (nobjs > 16)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp12) : &tempshared12;
    }
  }
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CreditDefaultSwap" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CreditDefaultSwap" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  ecode16 = SWIG_AsVal_unsigned_SS_int(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_CreditDefaultSwap" "', argument " "16"" of type '" "Natural""'");
  } 
  arg16 = static_cast< Natural >(val16);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12,(DayCounter const &)*arg13,arg14,(Date const &)*arg15,arg16);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  Date *arg15 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< Claim > tempshared12 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 15) || (nobjs > 15)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp12) : &tempshared12;
    }
  }
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CreditDefaultSwap" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(swig_obj[14], &argp15, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_CreditDefaultSwap" "', argument " "15"" of type '" "Date const &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "15"" of type '" "Date const &""'"); 
  }
  arg15 = reinterpret_cast< Date * >(argp15);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12,(DayCounter const &)*arg13,arg14,(Date const &)*arg15);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  bool arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< Claim > tempshared12 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 14) || (nobjs > 14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp12) : &tempshared12;
    }
  }
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  ecode14 = SWIG_AsVal_bool(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_CreditDefaultSwap" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12,(DayCounter const &)*arg13,arg14);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_12(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  DayCounter *arg13 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< Claim > tempshared12 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp12) : &tempshared12;
    }
  }
  res13 = SWIG_ConvertPtr(swig_obj[12], &argp13, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "13"" of type '" "DayCounter const &""'"); 
  }
  arg13 = reinterpret_cast< DayCounter * >(argp13);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12,(DayCounter const &)*arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_13(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  ext::shared_ptr< Claim > *arg12 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 ;
  int res12 = 0 ;
  ext::shared_ptr< Claim > tempshared12 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    int newmem = 0;
    res12 = SWIG_ConvertPtrAndOwn(swig_obj[11], &argp12, SWIGTYPE_p_ext__shared_ptrT_Claim_t,  0 , &newmem);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_CreditDefaultSwap" "', argument " "12"" of type '" "ext::shared_ptr< Claim > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp12) tempshared12 = *reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      delete reinterpret_cast< ext::shared_ptr< Claim > * >(argp12);
      arg12 = &tempshared12;
    } else {
      arg12 = (argp12) ? reinterpret_cast< ext::shared_ptr< Claim > * >(argp12) : &tempshared12;
    }
  }
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11,(ext::shared_ptr< Claim > const &)*arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_14(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  Date *arg11 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "11"" of type '" "Date const &""'"); 
  }
  arg11 = reinterpret_cast< Date * >(argp11);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10,(Date const &)*arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_15(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  Date *arg10 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "10"" of type '" "Date const &""'"); 
  }
  arg10 = reinterpret_cast< Date * >(argp10);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9,(Date const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_16(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  bool arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CreditDefaultSwap" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_17(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  bool arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CreditDefaultSwap" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap__SWIG_18(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Protection::Side arg1 ;
  Real arg2 ;
  Rate arg3 ;
  Rate arg4 ;
  Schedule *arg5 = 0 ;
  BusinessDayConvention arg6 ;
  DayCounter *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  CreditDefaultSwap *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CreditDefaultSwap" "', argument " "1"" of type '" "Protection::Side""'");
  } 
  arg1 = static_cast< Protection::Side >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CreditDefaultSwap" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CreditDefaultSwap" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CreditDefaultSwap" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Schedule,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "5"" of type '" "Schedule const &""'"); 
  }
  arg5 = reinterpret_cast< Schedule * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CreditDefaultSwap" "', argument " "6"" of type '" "BusinessDayConvention""'");
  } 
  arg6 = static_cast< BusinessDayConvention >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditDefaultSwap" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (CreditDefaultSwap *)new CreditDefaultSwap(arg1,arg2,arg3,arg4,(Schedule const &)*arg5,arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CreditDefaultSwap > *smartresult = result ? new ext::shared_ptr<  CreditDefaultSwap >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditDefaultSwap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[17] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CreditDefaultSwap", 0, 16, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CreditDefaultSwap__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CreditDefaultSwap__SWIG_7(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CreditDefaultSwap__SWIG_18(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CreditDefaultSwap__SWIG_6(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CreditDefaultSwap__SWIG_17(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_CreditDefaultSwap__SWIG_5(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_CreditDefaultSwap__SWIG_16(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_CreditDefaultSwap__SWIG_4(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_new_CreditDefaultSwap__SWIG_15(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_CreditDefaultSwap__SWIG_3(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_new_CreditDefaultSwap__SWIG_14(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_CreditDefaultSwap__SWIG_2(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_CreditDefaultSwap__SWIG_13(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CreditDefaultSwap__SWIG_1(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_new_CreditDefaultSwap__SWIG_12(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_unsigned_SS_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_CreditDefaultSwap__SWIG_0(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_CreditDefaultSwap__SWIG_11(self, argc, argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_CreditDefaultSwap__SWIG_10(self, argc, argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Schedule, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        int res = SWIG_ConvertPtr(argv[10], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          int res = SWIG_ConvertPtr(argv[11], 0, SWIGTYPE_p_ext__shared_ptrT_Claim_t, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                int res = SWIG_ConvertPtr(argv[14], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_unsigned_SS_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_CreditDefaultSwap__SWIG_9(self, argc, argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CreditDefaultSwap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &,bool const,Date const &,Natural)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &,bool const,Date const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &,bool const)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,ext::shared_ptr< Claim > const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Schedule const &,BusinessDayConvention,DayCounter const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &,bool const,Date const &,Natural)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &,bool const,Date const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &,bool const)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,Date const &,ext::shared_ptr< Claim > const &,DayCounter const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,Date const &,ext::shared_ptr< Claim > const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &,Date const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool,Date const &)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool,bool)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &,bool)\n"
    "    CreditDefaultSwap::CreditDefaultSwap(Protection::Side,Real,Rate,Rate,Schedule const &,BusinessDayConvention,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_side(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Protection::Side result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_side" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Protection::Side)((CreditDefaultSwap const *)arg1)->side();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_notional(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_notional" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->notional();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_runningSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_runningSpread" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->runningSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_upfront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  doubleOrNull result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_upfront" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = CreditDefaultSwap_upfront((CreditDefaultSwap const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    if (result == Null<double>()) {
      Py_INCREF(Py_None);
      resultobj = Py_None;
    } else {
      resultobj = PyFloat_FromDouble(result);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_settlesAccrual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_settlesAccrual" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CreditDefaultSwap const *)arg1)->settlesAccrual();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_paysAtDefaultTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_paysAtDefaultTime" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CreditDefaultSwap const *)arg1)->paysAtDefaultTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_coupons(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_coupons" "', argument " "1"" of type '" "CreditDefaultSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->coupons();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_protectionStartDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_protectionStartDate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Date *) &((CreditDefaultSwap const *)arg1)->protectionStartDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_protectionEndDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_protectionEndDate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Date *) &((CreditDefaultSwap const *)arg1)->protectionEndDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_rebatesAccrual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_rebatesAccrual" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((CreditDefaultSwap const *)arg1)->rebatesAccrual();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_upfrontPayment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CashFlow > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_upfrontPayment" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CreditDefaultSwap const *)arg1)->upfrontPayment();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_accrualRebate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CashFlow > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_accrualRebate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CreditDefaultSwap const *)arg1)->accrualRebate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CashFlow > *smartresult = result ? new ext::shared_ptr<  CashFlow >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CashFlow_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_tradeDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_tradeDate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Date *) &((CreditDefaultSwap const *)arg1)->tradeDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_cashSettlementDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Natural result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_cashSettlementDays" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Natural)((CreditDefaultSwap const *)arg1)->cashSettlementDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_fairUpfront(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_fairUpfront" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->fairUpfront();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_fairSpread(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_fairSpread" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->fairSpread();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_couponLegBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_couponLegBPS" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->couponLegBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_upfrontBPS(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_upfrontBPS" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->upfrontBPS();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_couponLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_couponLegNPV" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->couponLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_defaultLegNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_defaultLegNPV" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->defaultLegNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_upfrontNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_upfrontNPV" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->upfrontNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_accrualRebateNPV(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_accrualRebateNPV" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CreditDefaultSwap const *)arg1)->accrualRebateNPV();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_impliedHazardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  CreditDefaultSwap::PricingModel arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Rate result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "7"" of type '" "CreditDefaultSwap::PricingModel""'");
  } 
  arg7 = static_cast< CreditDefaultSwap::PricingModel >(val7);
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_impliedHazardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Rate result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_impliedHazardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_impliedHazardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_impliedHazardRate" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->impliedHazardRate(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_impliedHazardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CreditDefaultSwap_impliedHazardRate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CreditDefaultSwap_impliedHazardRate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CreditDefaultSwap_impliedHazardRate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CreditDefaultSwap_impliedHazardRate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CreditDefaultSwap_impliedHazardRate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CreditDefaultSwap_impliedHazardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CreditDefaultSwap::impliedHazardRate(Real,Handle< YieldTermStructure > const &,DayCounter const &,Real,Real,CreditDefaultSwap::PricingModel) const\n"
    "    CreditDefaultSwap::impliedHazardRate(Real,Handle< YieldTermStructure > const &,DayCounter const &,Real,Real) const\n"
    "    CreditDefaultSwap::impliedHazardRate(Real,Handle< YieldTermStructure > const &,DayCounter const &,Real) const\n"
    "    CreditDefaultSwap::impliedHazardRate(Real,Handle< YieldTermStructure > const &,DayCounter const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_conventionalSpread__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  CreditDefaultSwap::PricingModel arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Rate result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "5"" of type '" "CreditDefaultSwap::PricingModel""'");
  } 
  arg5 = static_cast< CreditDefaultSwap::PricingModel >(val5);
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->conventionalSpread(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_conventionalSpread__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap const > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Rate result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "1"" of type '" "CreditDefaultSwap const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreditDefaultSwap_conventionalSpread" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (Rate)((CreditDefaultSwap const *)arg1)->conventionalSpread(arg2,(Handle< YieldTermStructure > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CreditDefaultSwap_conventionalSpread(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CreditDefaultSwap_conventionalSpread", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CreditDefaultSwap_conventionalSpread__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CreditDefaultSwap_conventionalSpread__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CreditDefaultSwap_conventionalSpread'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CreditDefaultSwap::conventionalSpread(Real,Handle< YieldTermStructure > const &,DayCounter const &,CreditDefaultSwap::PricingModel) const\n"
    "    CreditDefaultSwap::conventionalSpread(Real,Handle< YieldTermStructure > const &,DayCounter const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CreditDefaultSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CreditDefaultSwap *arg1 = (CreditDefaultSwap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap > tempshared1 ;
  ext::shared_ptr< CreditDefaultSwap > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CreditDefaultSwap" "', argument " "1"" of type '" "CreditDefaultSwap *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CreditDefaultSwap > * >(argp1);
      arg1 = const_cast< CreditDefaultSwap * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CreditDefaultSwap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CreditDefaultSwap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MidPointCdsEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  MidPointCdsEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_MidPointCdsEngine", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MidPointCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MidPointCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MidPointCdsEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MidPointCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MidPointCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (MidPointCdsEngine *)new MidPointCdsEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MidPointCdsEngine > *smartresult = result ? new ext::shared_ptr<  MidPointCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MidPointCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MidPointCdsEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MidPointCdsEngine *arg1 = (MidPointCdsEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MidPointCdsEngine > tempshared1 ;
  ext::shared_ptr< MidPointCdsEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MidPointCdsEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MidPointCdsEngine" "', argument " "1"" of type '" "MidPointCdsEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MidPointCdsEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MidPointCdsEngine > * >(argp1);
      arg1 = const_cast< MidPointCdsEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MidPointCdsEngine > * >(argp1);
      arg1 = const_cast< MidPointCdsEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MidPointCdsEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MidPointCdsEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MidPointCdsEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IntegralCdsEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  IntegralCdsEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntegralCdsEngine" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntegralCdsEngine" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntegralCdsEngine" "', argument " "2"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntegralCdsEngine" "', argument " "2"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IntegralCdsEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IntegralCdsEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntegralCdsEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IntegralCdsEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (IntegralCdsEngine *)new IntegralCdsEngine((Period const &)*arg1,(Handle< DefaultProbabilityTermStructure > const &)*arg2,arg3,(Handle< YieldTermStructure > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IntegralCdsEngine > *smartresult = result ? new ext::shared_ptr<  IntegralCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IntegralCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegralCdsEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Period *arg1 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  IntegralCdsEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntegralCdsEngine" "', argument " "1"" of type '" "Period const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntegralCdsEngine" "', argument " "1"" of type '" "Period const &""'"); 
  }
  arg1 = reinterpret_cast< Period * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntegralCdsEngine" "', argument " "2"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntegralCdsEngine" "', argument " "2"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IntegralCdsEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_IntegralCdsEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntegralCdsEngine" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  {
    try {
      result = (IntegralCdsEngine *)new IntegralCdsEngine((Period const &)*arg1,(Handle< DefaultProbabilityTermStructure > const &)*arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IntegralCdsEngine > *smartresult = result ? new ext::shared_ptr<  IntegralCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IntegralCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntegralCdsEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntegralCdsEngine", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_IntegralCdsEngine__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_IntegralCdsEngine__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntegralCdsEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IntegralCdsEngine::IntegralCdsEngine(Period const &,Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &,bool)\n"
    "    IntegralCdsEngine::IntegralCdsEngine(Period const &,Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IntegralCdsEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IntegralCdsEngine *arg1 = (IntegralCdsEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IntegralCdsEngine > tempshared1 ;
  ext::shared_ptr< IntegralCdsEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IntegralCdsEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntegralCdsEngine" "', argument " "1"" of type '" "IntegralCdsEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IntegralCdsEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IntegralCdsEngine > * >(argp1);
      arg1 = const_cast< IntegralCdsEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IntegralCdsEngine > * >(argp1);
      arg1 = const_cast< IntegralCdsEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntegralCdsEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IntegralCdsEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntegralCdsEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_IsdaCdsEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine::NumericalFix arg5 ;
  IsdaCdsEngine::AccrualBias arg6 ;
  IsdaCdsEngine::ForwardsInCouponPeriod arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  IsdaCdsEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IsdaCdsEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IsdaCdsEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IsdaCdsEngine" "', argument " "5"" of type '" "IsdaCdsEngine::NumericalFix""'");
  } 
  arg5 = static_cast< IsdaCdsEngine::NumericalFix >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IsdaCdsEngine" "', argument " "6"" of type '" "IsdaCdsEngine::AccrualBias""'");
  } 
  arg6 = static_cast< IsdaCdsEngine::AccrualBias >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_IsdaCdsEngine" "', argument " "7"" of type '" "IsdaCdsEngine::ForwardsInCouponPeriod""'");
  } 
  arg7 = static_cast< IsdaCdsEngine::ForwardsInCouponPeriod >(val7);
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IsdaCdsEngine > *smartresult = result ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IsdaCdsEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine::NumericalFix arg5 ;
  IsdaCdsEngine::AccrualBias arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  IsdaCdsEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IsdaCdsEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IsdaCdsEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IsdaCdsEngine" "', argument " "5"" of type '" "IsdaCdsEngine::NumericalFix""'");
  } 
  arg5 = static_cast< IsdaCdsEngine::NumericalFix >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IsdaCdsEngine" "', argument " "6"" of type '" "IsdaCdsEngine::AccrualBias""'");
  } 
  arg6 = static_cast< IsdaCdsEngine::AccrualBias >(val6);
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IsdaCdsEngine > *smartresult = result ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IsdaCdsEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  IsdaCdsEngine::NumericalFix arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  IsdaCdsEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IsdaCdsEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IsdaCdsEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IsdaCdsEngine" "', argument " "5"" of type '" "IsdaCdsEngine::NumericalFix""'");
  } 
  arg5 = static_cast< IsdaCdsEngine::NumericalFix >(val5);
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IsdaCdsEngine > *smartresult = result ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IsdaCdsEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  IsdaCdsEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IsdaCdsEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IsdaCdsEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IsdaCdsEngine > *smartresult = result ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IsdaCdsEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  IsdaCdsEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IsdaCdsEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IsdaCdsEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  {
    try {
      result = (IsdaCdsEngine *)new IsdaCdsEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  IsdaCdsEngine > *smartresult = result ? new ext::shared_ptr<  IsdaCdsEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IsdaCdsEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IsdaCdsEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_IsdaCdsEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_IsdaCdsEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_IsdaCdsEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_IsdaCdsEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_IsdaCdsEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IsdaCdsEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IsdaCdsEngine::IsdaCdsEngine(Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &,bool,IsdaCdsEngine::NumericalFix const,IsdaCdsEngine::AccrualBias const,IsdaCdsEngine::ForwardsInCouponPeriod const)\n"
    "    IsdaCdsEngine::IsdaCdsEngine(Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &,bool,IsdaCdsEngine::NumericalFix const,IsdaCdsEngine::AccrualBias const)\n"
    "    IsdaCdsEngine::IsdaCdsEngine(Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &,bool,IsdaCdsEngine::NumericalFix const)\n"
    "    IsdaCdsEngine::IsdaCdsEngine(Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &,bool)\n"
    "    IsdaCdsEngine::IsdaCdsEngine(Handle< DefaultProbabilityTermStructure > const &,Real,Handle< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IsdaCdsEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IsdaCdsEngine *arg1 = (IsdaCdsEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< IsdaCdsEngine > tempshared1 ;
  ext::shared_ptr< IsdaCdsEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IsdaCdsEngine" "', argument " "1"" of type '" "IsdaCdsEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  IsdaCdsEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  IsdaCdsEngine > * >(argp1);
      arg1 = const_cast< IsdaCdsEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  IsdaCdsEngine > * >(argp1);
      arg1 = const_cast< IsdaCdsEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IsdaCdsEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_IsdaCdsEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IsdaCdsEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CdsOption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CreditDefaultSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  CdsOption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CdsOption" "', argument " "1"" of type '" "ext::shared_ptr< CreditDefaultSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CreditDefaultSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CreditDefaultSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CdsOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CdsOption" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (CdsOption *)new CdsOption((ext::shared_ptr< CreditDefaultSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CdsOption > *smartresult = result ? new ext::shared_ptr<  CdsOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CdsOption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CreditDefaultSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CreditDefaultSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  CdsOption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CdsOption" "', argument " "1"" of type '" "ext::shared_ptr< CreditDefaultSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CreditDefaultSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CreditDefaultSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CreditDefaultSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CdsOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (CdsOption *)new CdsOption((ext::shared_ptr< CreditDefaultSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CdsOption > *smartresult = result ? new ext::shared_ptr<  CdsOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CdsOption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CdsOption", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CdsOption__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CreditDefaultSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CdsOption__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CdsOption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CdsOption::CdsOption(ext::shared_ptr< CreditDefaultSwap > const &,ext::shared_ptr< Exercise > const &,bool)\n"
    "    CdsOption::CdsOption(ext::shared_ptr< CreditDefaultSwap > const &,ext::shared_ptr< Exercise > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CdsOption_atmRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_atmRate" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((CdsOption const *)arg1)->atmRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_riskyAnnuity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_riskyAnnuity" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CdsOption const *)arg1)->riskyAnnuity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  Volatility arg8 ;
  Volatility arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  Volatility result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_impliedVolatility" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdsOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CdsOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CdsOption_impliedVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CdsOption_impliedVolatility" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CdsOption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CdsOption_impliedVolatility" "', argument " "9"" of type '" "Volatility""'");
  } 
  arg9 = static_cast< Volatility >(val9);
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  Volatility arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Volatility result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_impliedVolatility" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdsOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CdsOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CdsOption_impliedVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CdsOption_impliedVolatility" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CdsOption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > const &)*arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  Size arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_impliedVolatility" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdsOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CdsOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CdsOption_impliedVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CdsOption_impliedVolatility" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > const &)*arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_impliedVolatility" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdsOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CdsOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CdsOption_impliedVolatility" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< DefaultProbabilityTermStructure > *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption const > tempshared1 ;
  ext::shared_ptr< CdsOption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdsOption_impliedVolatility" "', argument " "1"" of type '" "CdsOption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdsOption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CdsOption_impliedVolatility" "', argument " "4"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CdsOption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Volatility)((CdsOption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< DefaultProbabilityTermStructure > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CdsOption_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CdsOption_impliedVolatility", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CdsOption_impliedVolatility__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_CdsOption_impliedVolatility__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_CdsOption_impliedVolatility__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_CdsOption_impliedVolatility__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_CdsOption_impliedVolatility__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CdsOption_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CdsOption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Handle< DefaultProbabilityTermStructure > const &,Real,Real,Size,Volatility,Volatility) const\n"
    "    CdsOption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Handle< DefaultProbabilityTermStructure > const &,Real,Real,Size,Volatility) const\n"
    "    CdsOption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Handle< DefaultProbabilityTermStructure > const &,Real,Real,Size) const\n"
    "    CdsOption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Handle< DefaultProbabilityTermStructure > const &,Real,Real) const\n"
    "    CdsOption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Handle< DefaultProbabilityTermStructure > const &,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CdsOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CdsOption *arg1 = (CdsOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CdsOption > tempshared1 ;
  ext::shared_ptr< CdsOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CdsOption" "', argument " "1"" of type '" "CdsOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CdsOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CdsOption > * >(argp1);
      arg1 = const_cast< CdsOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CdsOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CdsOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CdsOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackCdsOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< DefaultProbabilityTermStructure > *arg1 = 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  BlackCdsOptionEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BlackCdsOptionEngine", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_DefaultProbabilityTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackCdsOptionEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCdsOptionEngine" "', argument " "1"" of type '" "Handle< DefaultProbabilityTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< DefaultProbabilityTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlackCdsOptionEngine" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackCdsOptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCdsOptionEngine" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BlackCdsOptionEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackCdsOptionEngine" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (BlackCdsOptionEngine *)new BlackCdsOptionEngine((Handle< DefaultProbabilityTermStructure > const &)*arg1,arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackCdsOptionEngine > *smartresult = result ? new ext::shared_ptr<  BlackCdsOptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackCdsOptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCdsOptionEngine_termStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCdsOptionEngine *arg1 = (BlackCdsOptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCdsOptionEngine > tempshared1 ;
  ext::shared_ptr< BlackCdsOptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< YieldTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCdsOptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCdsOptionEngine_termStructure" "', argument " "1"" of type '" "BlackCdsOptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      arg1 = const_cast< BlackCdsOptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      arg1 = const_cast< BlackCdsOptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->termStructure();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< YieldTermStructure >(result)), SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BlackCdsOptionEngine_volatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCdsOptionEngine *arg1 = (BlackCdsOptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCdsOptionEngine > tempshared1 ;
  ext::shared_ptr< BlackCdsOptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Handle< Quote > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCdsOptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlackCdsOptionEngine_volatility" "', argument " "1"" of type '" "BlackCdsOptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      arg1 = const_cast< BlackCdsOptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      arg1 = const_cast< BlackCdsOptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->volatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Handle< Quote >(result)), SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BlackCdsOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackCdsOptionEngine *arg1 = (BlackCdsOptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackCdsOptionEngine > tempshared1 ;
  ext::shared_ptr< BlackCdsOptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackCdsOptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackCdsOptionEngine" "', argument " "1"" of type '" "BlackCdsOptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      arg1 = const_cast< BlackCdsOptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackCdsOptionEngine > * >(argp1);
      arg1 = const_cast< BlackCdsOptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackCdsOptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackCdsOptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackCdsOptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDiscountCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_DiscountCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  arg5 = reinterpret_cast< LogLinear * >(argp5);
  {
    try {
      result = (InterpolatedDiscountCurve< LogLinear > *)new InterpolatedDiscountCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDiscountCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDiscountCurve< LogLinear > *)new InterpolatedDiscountCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDiscountCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDiscountCurve< LogLinear > *)new InterpolatedDiscountCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiscountCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_DiscountCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_DiscountCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_DiscountCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDiscountCurve< LogLinear >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &,LogLinear const &)\n"
    "    InterpolatedDiscountCurve< LogLinear >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDiscountCurve< LogLinear >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DiscountCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscountCurve_times" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedDiscountCurve< LogLinear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscountCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscountCurve_data" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDiscountCurve< LogLinear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscountCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscountCurve_dates" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDiscountCurve< LogLinear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscountCurve_discounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscountCurve_discounts" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< DiscountFactor,std::allocator< DiscountFactor > > *) &((InterpolatedDiscountCurve< LogLinear > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DiscountCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,DiscountFactor >,std::allocator< std::pair< Date,DiscountFactor > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscountCurve_nodes" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDiscountCurve< LogLinear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogLinear > *arg1 = (InterpolatedDiscountCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscountCurve" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogLinear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicLogCubicDiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicLogCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "5"" of type '" "MonotonicLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "5"" of type '" "MonotonicLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicLogCubic * >(argp5);
  {
    try {
      result = (InterpolatedDiscountCurve< MonotonicLogCubic > *)new InterpolatedDiscountCurve< MonotonicLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicLogCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicLogCubicDiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDiscountCurve< MonotonicLogCubic > *)new InterpolatedDiscountCurve< MonotonicLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicLogCubicDiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDiscountCurve< MonotonicLogCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDiscountCurve< MonotonicLogCubic > *)new InterpolatedDiscountCurve< MonotonicLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicLogCubicDiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MonotonicLogCubicDiscountCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MonotonicLogCubicDiscountCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MonotonicLogCubicDiscountCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_MonotonicLogCubicDiscountCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MonotonicLogCubicDiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDiscountCurve< MonotonicLogCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &,MonotonicLogCubic const &)\n"
    "    InterpolatedDiscountCurve< MonotonicLogCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDiscountCurve< MonotonicLogCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicDiscountCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicDiscountCurve_times" "', argument " "1"" of type '" "InterpolatedDiscountCurve< MonotonicLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicDiscountCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicDiscountCurve_data" "', argument " "1"" of type '" "InterpolatedDiscountCurve< MonotonicLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicDiscountCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicDiscountCurve_dates" "', argument " "1"" of type '" "InterpolatedDiscountCurve< MonotonicLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicDiscountCurve_discounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicDiscountCurve_discounts" "', argument " "1"" of type '" "InterpolatedDiscountCurve< MonotonicLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< DiscountFactor,std::allocator< DiscountFactor > > *) &((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicLogCubicDiscountCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,DiscountFactor >,std::allocator< std::pair< Date,DiscountFactor > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicLogCubicDiscountCurve_nodes" "', argument " "1"" of type '" "InterpolatedDiscountCurve< MonotonicLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDiscountCurve< MonotonicLogCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicLogCubicDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< MonotonicLogCubic > *arg1 = (InterpolatedDiscountCurve< MonotonicLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicLogCubicDiscountCurve" "', argument " "1"" of type '" "InterpolatedDiscountCurve< MonotonicLogCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<MonotonicLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< MonotonicLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicLogCubicDiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicLogCubicDiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NaturalCubicDiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDiscountCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  {
    try {
      result = (InterpolatedDiscountCurve< SplineCubic > *)new InterpolatedDiscountCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicDiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDiscountCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDiscountCurve< SplineCubic > *)new InterpolatedDiscountCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicDiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDiscountCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDiscountCurve< SplineCubic > *)new InterpolatedDiscountCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicDiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NaturalCubicDiscountCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NaturalCubicDiscountCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_NaturalCubicDiscountCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_NaturalCubicDiscountCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NaturalCubicDiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDiscountCurve< SplineCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &,SplineCubic const &)\n"
    "    InterpolatedDiscountCurve< SplineCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDiscountCurve< SplineCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NaturalCubicDiscountCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicDiscountCurve_times" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicDiscountCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicDiscountCurve_data" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicDiscountCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicDiscountCurve_dates" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicDiscountCurve_discounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicDiscountCurve_discounts" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< DiscountFactor,std::allocator< DiscountFactor > > *) &((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicDiscountCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,DiscountFactor >,std::allocator< std::pair< Date,DiscountFactor > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicDiscountCurve_nodes" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDiscountCurve< SplineCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NaturalCubicDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineCubic > *arg1 = (InterpolatedDiscountCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NaturalCubicDiscountCurve" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NaturalCubicDiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NaturalCubicDiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KrugerLogDiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  KrugerLog *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDiscountCurve< KrugerLog > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerLogDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerLogDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerLogDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KrugerLogDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_KrugerLog,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_KrugerLogDiscountCurve" "', argument " "5"" of type '" "KrugerLog const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "5"" of type '" "KrugerLog const &""'"); 
  }
  arg5 = reinterpret_cast< KrugerLog * >(argp5);
  {
    try {
      result = (InterpolatedDiscountCurve< KrugerLog > *)new InterpolatedDiscountCurve< KrugerLog >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(KrugerLog const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerLogDiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDiscountCurve< KrugerLog > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerLogDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerLogDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerLogDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KrugerLogDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDiscountCurve< KrugerLog > *)new InterpolatedDiscountCurve< KrugerLog >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerLogDiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDiscountCurve< KrugerLog > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerLogDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerLogDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerLogDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerLogDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDiscountCurve< KrugerLog > *)new InterpolatedDiscountCurve< KrugerLog >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerLogDiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KrugerLogDiscountCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_KrugerLogDiscountCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_KrugerLogDiscountCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_KrugerLog, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_KrugerLogDiscountCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KrugerLogDiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDiscountCurve< KrugerLog >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &,KrugerLog const &)\n"
    "    InterpolatedDiscountCurve< KrugerLog >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDiscountCurve< KrugerLog >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerLogDiscountCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogDiscountCurve_times" "', argument " "1"" of type '" "InterpolatedDiscountCurve< KrugerLog > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogDiscountCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogDiscountCurve_data" "', argument " "1"" of type '" "InterpolatedDiscountCurve< KrugerLog > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogDiscountCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogDiscountCurve_dates" "', argument " "1"" of type '" "InterpolatedDiscountCurve< KrugerLog > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogDiscountCurve_discounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogDiscountCurve_discounts" "', argument " "1"" of type '" "InterpolatedDiscountCurve< KrugerLog > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< DiscountFactor,std::allocator< DiscountFactor > > *) &((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerLogDiscountCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,DiscountFactor >,std::allocator< std::pair< Date,DiscountFactor > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerLogDiscountCurve_nodes" "', argument " "1"" of type '" "InterpolatedDiscountCurve< KrugerLog > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDiscountCurve< KrugerLog > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KrugerLogDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< KrugerLog > *arg1 = (InterpolatedDiscountCurve< KrugerLog > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KrugerLogDiscountCurve" "', argument " "1"" of type '" "InterpolatedDiscountCurve< KrugerLog > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<KrugerLog> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< KrugerLog > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KrugerLogDiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KrugerLogDiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NaturalLogCubicDiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  SplineLogCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDiscountCurve< SplineLogCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "5"" of type '" "SplineLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "5"" of type '" "SplineLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineLogCubic * >(argp5);
  {
    try {
      result = (InterpolatedDiscountCurve< SplineLogCubic > *)new InterpolatedDiscountCurve< SplineLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineLogCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalLogCubicDiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDiscountCurve< SplineLogCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDiscountCurve< SplineLogCubic > *)new InterpolatedDiscountCurve< SplineLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalLogCubicDiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDiscountCurve< SplineLogCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalLogCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDiscountCurve< SplineLogCubic > *)new InterpolatedDiscountCurve< SplineLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalLogCubicDiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NaturalLogCubicDiscountCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NaturalLogCubicDiscountCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_NaturalLogCubicDiscountCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_NaturalLogCubicDiscountCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NaturalLogCubicDiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDiscountCurve< SplineLogCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &,SplineLogCubic const &)\n"
    "    InterpolatedDiscountCurve< SplineLogCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDiscountCurve< SplineLogCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NaturalLogCubicDiscountCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalLogCubicDiscountCurve_times" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalLogCubicDiscountCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalLogCubicDiscountCurve_data" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalLogCubicDiscountCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalLogCubicDiscountCurve_dates" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalLogCubicDiscountCurve_discounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalLogCubicDiscountCurve_discounts" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< DiscountFactor,std::allocator< DiscountFactor > > *) &((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalLogCubicDiscountCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,DiscountFactor >,std::allocator< std::pair< Date,DiscountFactor > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalLogCubicDiscountCurve_nodes" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDiscountCurve< SplineLogCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NaturalLogCubicDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< SplineLogCubic > *arg1 = (InterpolatedDiscountCurve< SplineLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NaturalLogCubicDiscountCurve" "', argument " "1"" of type '" "InterpolatedDiscountCurve< SplineLogCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<SplineLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< SplineLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NaturalLogCubicDiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NaturalLogCubicDiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogMixedLinearCubicDiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogMixedLinearCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogMixedLinearCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "5"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "5"" of type '" "LogMixedLinearCubic const &""'"); 
  }
  arg5 = reinterpret_cast< LogMixedLinearCubic * >(argp5);
  {
    try {
      result = (InterpolatedDiscountCurve< LogMixedLinearCubic > *)new InterpolatedDiscountCurve< LogMixedLinearCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogMixedLinearCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogMixedLinearCubicDiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedDiscountCurve< LogMixedLinearCubic > *)new InterpolatedDiscountCurve< LogMixedLinearCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogMixedLinearCubicDiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMixedLinearCubicDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedDiscountCurve< LogMixedLinearCubic > *)new InterpolatedDiscountCurve< LogMixedLinearCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogMixedLinearCubicDiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LogMixedLinearCubicDiscountCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LogMixedLinearCubicDiscountCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LogMixedLinearCubicDiscountCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogMixedLinearCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LogMixedLinearCubicDiscountCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LogMixedLinearCubicDiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedDiscountCurve< LogMixedLinearCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &,LogMixedLinearCubic const &)\n"
    "    InterpolatedDiscountCurve< LogMixedLinearCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedDiscountCurve< LogMixedLinearCubic >::InterpolatedDiscountCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogMixedLinearCubicDiscountCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMixedLinearCubicDiscountCurve_times" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogMixedLinearCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogMixedLinearCubicDiscountCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMixedLinearCubicDiscountCurve_data" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogMixedLinearCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogMixedLinearCubicDiscountCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMixedLinearCubicDiscountCurve_dates" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogMixedLinearCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogMixedLinearCubicDiscountCurve_discounts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMixedLinearCubicDiscountCurve_discounts" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogMixedLinearCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< DiscountFactor,std::allocator< DiscountFactor > > *) &((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->discounts();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogMixedLinearCubicDiscountCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,DiscountFactor >,std::allocator< std::pair< Date,DiscountFactor > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMixedLinearCubicDiscountCurve_nodes" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogMixedLinearCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedDiscountCurve< LogMixedLinearCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LogMixedLinearCubicDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedDiscountCurve< LogMixedLinearCubic > *arg1 = (InterpolatedDiscountCurve< LogMixedLinearCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogMixedLinearCubicDiscountCurve" "', argument " "1"" of type '" "InterpolatedDiscountCurve< LogMixedLinearCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedDiscountCurve<LogMixedLinearCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedDiscountCurve< LogMixedLinearCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogMixedLinearCubicDiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogMixedLinearCubicDiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NormalDistribution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  NormalDistribution *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NormalDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NormalDistribution" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (NormalDistribution *)new NormalDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NormalDistribution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  NormalDistribution *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NormalDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (NormalDistribution *)new NormalDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NormalDistribution__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  NormalDistribution *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (NormalDistribution *)new NormalDistribution();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NormalDistribution(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NormalDistribution", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NormalDistribution__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_NormalDistribution__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_NormalDistribution__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NormalDistribution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NormalDistribution::NormalDistribution(Real,Real)\n"
    "    NormalDistribution::NormalDistribution(Real)\n"
    "    NormalDistribution::NormalDistribution()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NormalDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NormalDistribution *arg1 = (NormalDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "NormalDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NormalDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalDistribution___call__" "', argument " "1"" of type '" "NormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< NormalDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NormalDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NormalDistribution_derivative(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NormalDistribution *arg1 = (NormalDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "NormalDistribution_derivative", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NormalDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalDistribution_derivative" "', argument " "1"" of type '" "NormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< NormalDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NormalDistribution_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->derivative(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NormalDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NormalDistribution *arg1 = (NormalDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NormalDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalDistribution" "', argument " "1"" of type '" "NormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< NormalDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NormalDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_NormalDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NormalDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CumulativeNormalDistribution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  CumulativeNormalDistribution *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativeNormalDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CumulativeNormalDistribution" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (CumulativeNormalDistribution *)new CumulativeNormalDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeNormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumulativeNormalDistribution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  CumulativeNormalDistribution *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativeNormalDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (CumulativeNormalDistribution *)new CumulativeNormalDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeNormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumulativeNormalDistribution__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  CumulativeNormalDistribution *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (CumulativeNormalDistribution *)new CumulativeNormalDistribution();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeNormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumulativeNormalDistribution(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CumulativeNormalDistribution", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CumulativeNormalDistribution__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CumulativeNormalDistribution__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CumulativeNormalDistribution__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CumulativeNormalDistribution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CumulativeNormalDistribution::CumulativeNormalDistribution(Real,Real)\n"
    "    CumulativeNormalDistribution::CumulativeNormalDistribution(Real)\n"
    "    CumulativeNormalDistribution::CumulativeNormalDistribution()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CumulativeNormalDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeNormalDistribution *arg1 = (CumulativeNormalDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativeNormalDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeNormalDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativeNormalDistribution___call__" "', argument " "1"" of type '" "CumulativeNormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeNormalDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativeNormalDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CumulativeNormalDistribution_derivative(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeNormalDistribution *arg1 = (CumulativeNormalDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativeNormalDistribution_derivative", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeNormalDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativeNormalDistribution_derivative" "', argument " "1"" of type '" "CumulativeNormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeNormalDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativeNormalDistribution_derivative" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->derivative(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CumulativeNormalDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeNormalDistribution *arg1 = (CumulativeNormalDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeNormalDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumulativeNormalDistribution" "', argument " "1"" of type '" "CumulativeNormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeNormalDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumulativeNormalDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CumulativeNormalDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CumulativeNormalDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InverseCumulativeNormal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  InverseCumulativeNormal *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseCumulativeNormal" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InverseCumulativeNormal" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (InverseCumulativeNormal *)new InverseCumulativeNormal(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseCumulativeNormal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  InverseCumulativeNormal *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseCumulativeNormal" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (InverseCumulativeNormal *)new InverseCumulativeNormal(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseCumulativeNormal__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  InverseCumulativeNormal *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (InverseCumulativeNormal *)new InverseCumulativeNormal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseCumulativeNormal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseCumulativeNormal", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_InverseCumulativeNormal__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InverseCumulativeNormal__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_InverseCumulativeNormal__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseCumulativeNormal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeNormal::InverseCumulativeNormal(Real,Real)\n"
    "    InverseCumulativeNormal::InverseCumulativeNormal(Real)\n"
    "    InverseCumulativeNormal::InverseCumulativeNormal()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InverseCumulativeNormal___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeNormal *arg1 = (InverseCumulativeNormal *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "InverseCumulativeNormal___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseCumulativeNormal___call__" "', argument " "1"" of type '" "InverseCumulativeNormal *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeNormal * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseCumulativeNormal___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InverseCumulativeNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeNormal *arg1 = (InverseCumulativeNormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseCumulativeNormal" "', argument " "1"" of type '" "InverseCumulativeNormal *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeNormal * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InverseCumulativeNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InverseCumulativeNormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInverseCumulativeNormal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  MoroInverseCumulativeNormal *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MoroInverseCumulativeNormal" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoroInverseCumulativeNormal" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (MoroInverseCumulativeNormal *)new MoroInverseCumulativeNormal(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInverseCumulativeNormal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  MoroInverseCumulativeNormal *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MoroInverseCumulativeNormal" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (MoroInverseCumulativeNormal *)new MoroInverseCumulativeNormal(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInverseCumulativeNormal__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  MoroInverseCumulativeNormal *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (MoroInverseCumulativeNormal *)new MoroInverseCumulativeNormal();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInverseCumulativeNormal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInverseCumulativeNormal", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MoroInverseCumulativeNormal__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MoroInverseCumulativeNormal__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MoroInverseCumulativeNormal__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInverseCumulativeNormal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MoroInverseCumulativeNormal::MoroInverseCumulativeNormal(Real,Real)\n"
    "    MoroInverseCumulativeNormal::MoroInverseCumulativeNormal(Real)\n"
    "    MoroInverseCumulativeNormal::MoroInverseCumulativeNormal()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInverseCumulativeNormal___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MoroInverseCumulativeNormal *arg1 = (MoroInverseCumulativeNormal *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "MoroInverseCumulativeNormal___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MoroInverseCumulativeNormal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInverseCumulativeNormal___call__" "', argument " "1"" of type '" "MoroInverseCumulativeNormal *""'"); 
  }
  arg1 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoroInverseCumulativeNormal___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInverseCumulativeNormal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MoroInverseCumulativeNormal *arg1 = (MoroInverseCumulativeNormal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInverseCumulativeNormal" "', argument " "1"" of type '" "MoroInverseCumulativeNormal *""'"); 
  }
  arg1 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInverseCumulativeNormal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInverseCumulativeNormal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BivariateCumulativeNormalDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  BivariateCumulativeNormalDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BivariateCumulativeNormalDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (BivariateCumulativeNormalDistribution *)new BivariateCumulativeNormalDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BivariateCumulativeNormalDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BivariateCumulativeNormalDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BivariateCumulativeNormalDistribution *arg1 = (BivariateCumulativeNormalDistribution *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BivariateCumulativeNormalDistribution___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BivariateCumulativeNormalDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BivariateCumulativeNormalDistribution___call__" "', argument " "1"" of type '" "BivariateCumulativeNormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< BivariateCumulativeNormalDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BivariateCumulativeNormalDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BivariateCumulativeNormalDistribution___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BivariateCumulativeNormalDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BivariateCumulativeNormalDistribution *arg1 = (BivariateCumulativeNormalDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BivariateCumulativeNormalDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BivariateCumulativeNormalDistribution" "', argument " "1"" of type '" "BivariateCumulativeNormalDistribution *""'"); 
  }
  arg1 = reinterpret_cast< BivariateCumulativeNormalDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BivariateCumulativeNormalDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BivariateCumulativeNormalDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BivariateCumulativeNormalDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BinomialDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  BigNatural arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  BinomialDistribution *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_BinomialDistribution", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BinomialDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BinomialDistribution" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (BinomialDistribution *)new BinomialDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BinomialDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BinomialDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDistribution *arg1 = (BinomialDistribution *) 0 ;
  BigNatural arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BinomialDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BinomialDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinomialDistribution___call__" "', argument " "1"" of type '" "BinomialDistribution *""'"); 
  }
  arg1 = reinterpret_cast< BinomialDistribution * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BinomialDistribution___call__" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BinomialDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BinomialDistribution *arg1 = (BinomialDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BinomialDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinomialDistribution" "', argument " "1"" of type '" "BinomialDistribution *""'"); 
  }
  arg1 = reinterpret_cast< BinomialDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BinomialDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BinomialDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BinomialDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CumulativeBinomialDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  BigNatural arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  CumulativeBinomialDistribution *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CumulativeBinomialDistribution", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativeBinomialDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CumulativeBinomialDistribution" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (CumulativeBinomialDistribution *)new CumulativeBinomialDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeBinomialDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CumulativeBinomialDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeBinomialDistribution *arg1 = (CumulativeBinomialDistribution *) 0 ;
  BigNatural arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativeBinomialDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeBinomialDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativeBinomialDistribution___call__" "', argument " "1"" of type '" "CumulativeBinomialDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeBinomialDistribution * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativeBinomialDistribution___call__" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CumulativeBinomialDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeBinomialDistribution *arg1 = (CumulativeBinomialDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeBinomialDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumulativeBinomialDistribution" "', argument " "1"" of type '" "CumulativeBinomialDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeBinomialDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumulativeBinomialDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CumulativeBinomialDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CumulativeBinomialDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BivariateCumulativeNormalDistributionDr78(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  BivariateCumulativeNormalDistributionDr78 *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BivariateCumulativeNormalDistributionDr78" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (BivariateCumulativeNormalDistributionDr78 *)new BivariateCumulativeNormalDistributionDr78(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BivariateCumulativeNormalDistributionDr78, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BivariateCumulativeNormalDistributionDr78___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BivariateCumulativeNormalDistributionDr78 *arg1 = (BivariateCumulativeNormalDistributionDr78 *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BivariateCumulativeNormalDistributionDr78___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BivariateCumulativeNormalDistributionDr78, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BivariateCumulativeNormalDistributionDr78___call__" "', argument " "1"" of type '" "BivariateCumulativeNormalDistributionDr78 *""'"); 
  }
  arg1 = reinterpret_cast< BivariateCumulativeNormalDistributionDr78 * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BivariateCumulativeNormalDistributionDr78___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BivariateCumulativeNormalDistributionDr78___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BivariateCumulativeNormalDistributionDr78(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BivariateCumulativeNormalDistributionDr78 *arg1 = (BivariateCumulativeNormalDistributionDr78 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BivariateCumulativeNormalDistributionDr78, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BivariateCumulativeNormalDistributionDr78" "', argument " "1"" of type '" "BivariateCumulativeNormalDistributionDr78 *""'"); 
  }
  arg1 = reinterpret_cast< BivariateCumulativeNormalDistributionDr78 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BivariateCumulativeNormalDistributionDr78_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BivariateCumulativeNormalDistributionDr78, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BivariateCumulativeNormalDistributionDr78_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BivariateCumulativeNormalDistributionWe04DP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  BivariateCumulativeNormalDistributionWe04DP *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BivariateCumulativeNormalDistributionWe04DP" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (BivariateCumulativeNormalDistributionWe04DP *)new BivariateCumulativeNormalDistributionWe04DP(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BivariateCumulativeNormalDistributionWe04DP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BivariateCumulativeNormalDistributionWe04DP___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BivariateCumulativeNormalDistributionWe04DP *arg1 = (BivariateCumulativeNormalDistributionWe04DP *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BivariateCumulativeNormalDistributionWe04DP___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BivariateCumulativeNormalDistributionWe04DP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BivariateCumulativeNormalDistributionWe04DP___call__" "', argument " "1"" of type '" "BivariateCumulativeNormalDistributionWe04DP *""'"); 
  }
  arg1 = reinterpret_cast< BivariateCumulativeNormalDistributionWe04DP * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BivariateCumulativeNormalDistributionWe04DP___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BivariateCumulativeNormalDistributionWe04DP___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BivariateCumulativeNormalDistributionWe04DP(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BivariateCumulativeNormalDistributionWe04DP *arg1 = (BivariateCumulativeNormalDistributionWe04DP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BivariateCumulativeNormalDistributionWe04DP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BivariateCumulativeNormalDistributionWe04DP" "', argument " "1"" of type '" "BivariateCumulativeNormalDistributionWe04DP *""'"); 
  }
  arg1 = reinterpret_cast< BivariateCumulativeNormalDistributionWe04DP * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BivariateCumulativeNormalDistributionWe04DP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BivariateCumulativeNormalDistributionWe04DP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BivariateCumulativeNormalDistributionWe04DP_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CumulativeChiSquareDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  CumulativeChiSquareDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativeChiSquareDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (CumulativeChiSquareDistribution *)new CumulativeChiSquareDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeChiSquareDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CumulativeChiSquareDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeChiSquareDistribution *arg1 = (CumulativeChiSquareDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativeChiSquareDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeChiSquareDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativeChiSquareDistribution___call__" "', argument " "1"" of type '" "CumulativeChiSquareDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeChiSquareDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativeChiSquareDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CumulativeChiSquareDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeChiSquareDistribution *arg1 = (CumulativeChiSquareDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeChiSquareDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumulativeChiSquareDistribution" "', argument " "1"" of type '" "CumulativeChiSquareDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeChiSquareDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumulativeChiSquareDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CumulativeChiSquareDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CumulativeChiSquareDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NonCentralCumulativeChiSquareDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  NonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NonCentralCumulativeChiSquareDistribution", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NonCentralCumulativeChiSquareDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NonCentralCumulativeChiSquareDistribution" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (NonCentralCumulativeChiSquareDistribution *)new NonCentralCumulativeChiSquareDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonCentralCumulativeChiSquareDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonCentralCumulativeChiSquareDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonCentralCumulativeChiSquareDistribution *arg1 = (NonCentralCumulativeChiSquareDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "NonCentralCumulativeChiSquareDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NonCentralCumulativeChiSquareDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonCentralCumulativeChiSquareDistribution___call__" "', argument " "1"" of type '" "NonCentralCumulativeChiSquareDistribution *""'"); 
  }
  arg1 = reinterpret_cast< NonCentralCumulativeChiSquareDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NonCentralCumulativeChiSquareDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NonCentralCumulativeChiSquareDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonCentralCumulativeChiSquareDistribution *arg1 = (NonCentralCumulativeChiSquareDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_NonCentralCumulativeChiSquareDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonCentralCumulativeChiSquareDistribution" "', argument " "1"" of type '" "NonCentralCumulativeChiSquareDistribution *""'"); 
  }
  arg1 = reinterpret_cast< NonCentralCumulativeChiSquareDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NonCentralCumulativeChiSquareDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_NonCentralCumulativeChiSquareDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NonCentralCumulativeChiSquareDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  InverseNonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (InverseNonCentralCumulativeChiSquareDistribution *)new InverseNonCentralCumulativeChiSquareDistribution(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  InverseNonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (InverseNonCentralCumulativeChiSquareDistribution *)new InverseNonCentralCumulativeChiSquareDistribution(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  InverseNonCentralCumulativeChiSquareDistribution *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (InverseNonCentralCumulativeChiSquareDistribution *)new InverseNonCentralCumulativeChiSquareDistribution(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseNonCentralCumulativeChiSquareDistribution(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseNonCentralCumulativeChiSquareDistribution", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_InverseNonCentralCumulativeChiSquareDistribution__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseNonCentralCumulativeChiSquareDistribution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseNonCentralCumulativeChiSquareDistribution::InverseNonCentralCumulativeChiSquareDistribution(Real,Real,Size,Real)\n"
    "    InverseNonCentralCumulativeChiSquareDistribution::InverseNonCentralCumulativeChiSquareDistribution(Real,Real,Size)\n"
    "    InverseNonCentralCumulativeChiSquareDistribution::InverseNonCentralCumulativeChiSquareDistribution(Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InverseNonCentralCumulativeChiSquareDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseNonCentralCumulativeChiSquareDistribution *arg1 = (InverseNonCentralCumulativeChiSquareDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "InverseNonCentralCumulativeChiSquareDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseNonCentralCumulativeChiSquareDistribution___call__" "', argument " "1"" of type '" "InverseNonCentralCumulativeChiSquareDistribution *""'"); 
  }
  arg1 = reinterpret_cast< InverseNonCentralCumulativeChiSquareDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseNonCentralCumulativeChiSquareDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InverseNonCentralCumulativeChiSquareDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseNonCentralCumulativeChiSquareDistribution *arg1 = (InverseNonCentralCumulativeChiSquareDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseNonCentralCumulativeChiSquareDistribution" "', argument " "1"" of type '" "InverseNonCentralCumulativeChiSquareDistribution *""'"); 
  }
  arg1 = reinterpret_cast< InverseNonCentralCumulativeChiSquareDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InverseNonCentralCumulativeChiSquareDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseNonCentralCumulativeChiSquareDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InverseNonCentralCumulativeChiSquareDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CumulativeGammaDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  CumulativeGammaDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativeGammaDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (CumulativeGammaDistribution *)new CumulativeGammaDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeGammaDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CumulativeGammaDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeGammaDistribution *arg1 = (CumulativeGammaDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativeGammaDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeGammaDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativeGammaDistribution___call__" "', argument " "1"" of type '" "CumulativeGammaDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeGammaDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativeGammaDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CumulativeGammaDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeGammaDistribution *arg1 = (CumulativeGammaDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeGammaDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumulativeGammaDistribution" "', argument " "1"" of type '" "CumulativeGammaDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeGammaDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumulativeGammaDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CumulativeGammaDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CumulativeGammaDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_GammaFunction_logValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GammaFunction *arg1 = (GammaFunction *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GammaFunction_logValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GammaFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaFunction_logValue" "', argument " "1"" of type '" "GammaFunction *""'"); 
  }
  arg1 = reinterpret_cast< GammaFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaFunction_logValue" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->logValue(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GammaFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GammaFunction *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GammaFunction", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (GammaFunction *)new GammaFunction();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GammaFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GammaFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GammaFunction *arg1 = (GammaFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GammaFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GammaFunction" "', argument " "1"" of type '" "GammaFunction *""'"); 
  }
  arg1 = reinterpret_cast< GammaFunction * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GammaFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GammaFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GammaFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_PoissonDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  PoissonDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PoissonDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (PoissonDistribution *)new PoissonDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PoissonDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PoissonDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PoissonDistribution *arg1 = (PoissonDistribution *) 0 ;
  BigNatural arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "PoissonDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PoissonDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PoissonDistribution___call__" "', argument " "1"" of type '" "PoissonDistribution *""'"); 
  }
  arg1 = reinterpret_cast< PoissonDistribution * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PoissonDistribution___call__" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PoissonDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PoissonDistribution *arg1 = (PoissonDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PoissonDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PoissonDistribution" "', argument " "1"" of type '" "PoissonDistribution *""'"); 
  }
  arg1 = reinterpret_cast< PoissonDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PoissonDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PoissonDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PoissonDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CumulativePoissonDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  CumulativePoissonDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativePoissonDistribution" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (CumulativePoissonDistribution *)new CumulativePoissonDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativePoissonDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CumulativePoissonDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativePoissonDistribution *arg1 = (CumulativePoissonDistribution *) 0 ;
  BigNatural arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativePoissonDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativePoissonDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativePoissonDistribution___call__" "', argument " "1"" of type '" "CumulativePoissonDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativePoissonDistribution * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativePoissonDistribution___call__" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CumulativePoissonDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativePoissonDistribution *arg1 = (CumulativePoissonDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativePoissonDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumulativePoissonDistribution" "', argument " "1"" of type '" "CumulativePoissonDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativePoissonDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumulativePoissonDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CumulativePoissonDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CumulativePoissonDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InverseCumulativePoisson(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativePoisson *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseCumulativePoisson" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (InverseCumulativePoisson *)new InverseCumulativePoisson(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativePoisson, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InverseCumulativePoisson___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativePoisson *arg1 = (InverseCumulativePoisson *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "InverseCumulativePoisson___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativePoisson, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseCumulativePoisson___call__" "', argument " "1"" of type '" "InverseCumulativePoisson *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativePoisson * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseCumulativePoisson___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InverseCumulativePoisson(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativePoisson *arg1 = (InverseCumulativePoisson *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativePoisson, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseCumulativePoisson" "', argument " "1"" of type '" "InverseCumulativePoisson *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativePoisson * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InverseCumulativePoisson_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativePoisson, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InverseCumulativePoisson_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StudentDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  StudentDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StudentDistribution" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (StudentDistribution *)new StudentDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StudentDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StudentDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StudentDistribution *arg1 = (StudentDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "StudentDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StudentDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StudentDistribution___call__" "', argument " "1"" of type '" "StudentDistribution *""'"); 
  }
  arg1 = reinterpret_cast< StudentDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StudentDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StudentDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StudentDistribution *arg1 = (StudentDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_StudentDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StudentDistribution" "', argument " "1"" of type '" "StudentDistribution *""'"); 
  }
  arg1 = reinterpret_cast< StudentDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StudentDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_StudentDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StudentDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CumulativeStudentDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  CumulativeStudentDistribution *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CumulativeStudentDistribution" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (CumulativeStudentDistribution *)new CumulativeStudentDistribution(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CumulativeStudentDistribution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CumulativeStudentDistribution___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeStudentDistribution *arg1 = (CumulativeStudentDistribution *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CumulativeStudentDistribution___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeStudentDistribution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CumulativeStudentDistribution___call__" "', argument " "1"" of type '" "CumulativeStudentDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeStudentDistribution * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CumulativeStudentDistribution___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CumulativeStudentDistribution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CumulativeStudentDistribution *arg1 = (CumulativeStudentDistribution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CumulativeStudentDistribution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumulativeStudentDistribution" "', argument " "1"" of type '" "CumulativeStudentDistribution *""'"); 
  }
  arg1 = reinterpret_cast< CumulativeStudentDistribution * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumulativeStudentDistribution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CumulativeStudentDistribution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CumulativeStudentDistribution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InverseCumulativeStudent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  Size arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  InverseCumulativeStudent *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseCumulativeStudent" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InverseCumulativeStudent" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InverseCumulativeStudent" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (InverseCumulativeStudent *)new InverseCumulativeStudent(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeStudent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseCumulativeStudent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Real arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  InverseCumulativeStudent *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseCumulativeStudent" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InverseCumulativeStudent" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (InverseCumulativeStudent *)new InverseCumulativeStudent(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeStudent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseCumulativeStudent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  InverseCumulativeStudent *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InverseCumulativeStudent" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  {
    try {
      result = (InverseCumulativeStudent *)new InverseCumulativeStudent(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeStudent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InverseCumulativeStudent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseCumulativeStudent", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InverseCumulativeStudent__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_InverseCumulativeStudent__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_InverseCumulativeStudent__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseCumulativeStudent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeStudent::InverseCumulativeStudent(Integer,Real,Size)\n"
    "    InverseCumulativeStudent::InverseCumulativeStudent(Integer,Real)\n"
    "    InverseCumulativeStudent::InverseCumulativeStudent(Integer)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InverseCumulativeStudent___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeStudent *arg1 = (InverseCumulativeStudent *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "InverseCumulativeStudent___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeStudent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseCumulativeStudent___call__" "', argument " "1"" of type '" "InverseCumulativeStudent *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeStudent * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseCumulativeStudent___call__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)(arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InverseCumulativeStudent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeStudent *arg1 = (InverseCumulativeStudent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeStudent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseCumulativeStudent" "', argument " "1"" of type '" "InverseCumulativeStudent *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeStudent * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InverseCumulativeStudent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeStudent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InverseCumulativeStudent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Money__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Currency *arg1 = 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Money *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Money" "', argument " "1"" of type '" "Currency const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Money" "', argument " "1"" of type '" "Currency const &""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Money" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = (Money *)new Money((Currency const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Money, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Money__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Decimal arg1 ;
  Currency *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Money *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Money" "', argument " "1"" of type '" "Decimal""'");
  } 
  arg1 = static_cast< Decimal >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Money" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Money" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  arg2 = reinterpret_cast< Currency * >(argp2);
  {
    try {
      result = (Money *)new Money(arg1,(Currency const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Money, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Money(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Money", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Money__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Money__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Money'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Money::Money(Currency const &,Decimal)\n"
    "    Money::Money(Decimal,Currency const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Money_currency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Currency *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money_currency" "', argument " "1"" of type '" "Money const *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      result = (Currency *) &((Money const *)arg1)->currency();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Decimal result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money_value" "', argument " "1"" of type '" "Money const *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      result = (Decimal)((Money const *)arg1)->value();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money_rounded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Money > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money_rounded" "', argument " "1"" of type '" "Money const *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      result = ((Money const *)arg1)->rounded();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money___pos__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Money > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___pos__" "', argument " "1"" of type '" "Money const *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      result = ((Money const *)arg1)->operator +();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Money > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___neg__" "', argument " "1"" of type '" "Money const *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      result = ((Money const *)arg1)->operator -();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___add__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___add__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___add__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = Money_operator_Sa_(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___sub__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___sub__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___sub__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = Money_operator_Ss_(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___mul__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Money___mul__" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = Money_operator_Sm_(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___truediv____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Money > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___truediv__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Money___truediv__" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = Money_operator_Sd___SWIG_0(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___truediv____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Decimal result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___truediv__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___truediv__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___truediv__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = (Decimal)Money_operator_Sd___SWIG_1(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___truediv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Money___truediv__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Money, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Money, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Money___truediv____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Money, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Money___truediv____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Decimal arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___rmul__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Money___rmul__" "', argument " "2"" of type '" "Decimal""'");
  } 
  arg2 = static_cast< Decimal >(val2);
  {
    try {
      result = Money___rmul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___lt__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___lt__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___lt__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = (bool)Money___lt__(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___gt__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___gt__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___gt__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = (bool)Money___gt__(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___le__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___le__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___le__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = (bool)Money___le__(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___ge__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___ge__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___ge__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = (bool)Money___ge__(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Money___cmp__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "Money___cmp__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___cmp__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Money___cmp__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money___cmp__" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = (int)Money___cmp__(arg1,(Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money___str__" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      result = Money___str__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money_setConversionType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money::ConversionType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Money_setConversionType" "', argument " "1"" of type '" "Money::ConversionType""'");
  } 
  arg1 = static_cast< Money::ConversionType >(val1);
  {
    try {
      Money_setConversionType(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Money_setBaseCurrency(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Money_setBaseCurrency" "', argument " "1"" of type '" "Currency const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Money_setBaseCurrency" "', argument " "1"" of type '" "Currency const &""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  {
    try {
      Money_setBaseCurrency((Currency const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Money(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Money *arg1 = (Money *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Money, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Money" "', argument " "1"" of type '" "Money *""'"); 
  }
  arg1 = reinterpret_cast< Money * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Money_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Money, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Money_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExchangeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Currency *arg1 = 0 ;
  Currency *arg2 = 0 ;
  Decimal arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  ExchangeRate *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ExchangeRate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExchangeRate" "', argument " "1"" of type '" "Currency const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExchangeRate" "', argument " "1"" of type '" "Currency const &""'"); 
  }
  arg1 = reinterpret_cast< Currency * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExchangeRate" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExchangeRate" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  arg2 = reinterpret_cast< Currency * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExchangeRate" "', argument " "3"" of type '" "Decimal""'");
  } 
  arg3 = static_cast< Decimal >(val3);
  {
    try {
      result = (ExchangeRate *)new ExchangeRate((Currency const &)*arg1,(Currency const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExchangeRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_source(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Currency *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRate_source" "', argument " "1"" of type '" "ExchangeRate const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  {
    try {
      result = (Currency *) &((ExchangeRate const *)arg1)->source();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_target(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Currency *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRate_target" "', argument " "1"" of type '" "ExchangeRate const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  {
    try {
      result = (Currency *) &((ExchangeRate const *)arg1)->target();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Currency, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ExchangeRate::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRate_type" "', argument " "1"" of type '" "ExchangeRate const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  {
    try {
      result = (ExchangeRate::Type)((ExchangeRate const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_rate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Decimal result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRate_rate" "', argument " "1"" of type '" "ExchangeRate const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  {
    try {
      result = (Decimal)((ExchangeRate const *)arg1)->rate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_exchange(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  Money *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< Money > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ExchangeRate_exchange", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRate_exchange" "', argument " "1"" of type '" "ExchangeRate const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Money,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRate_exchange" "', argument " "2"" of type '" "Money const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRate_exchange" "', argument " "2"" of type '" "Money const &""'"); 
  }
  arg2 = reinterpret_cast< Money * >(argp2);
  {
    try {
      result = ((ExchangeRate const *)arg1)->exchange((Money const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Money(result)), SWIGTYPE_p_Money, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRate_chain(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = 0 ;
  ExchangeRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< ExchangeRate > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ExchangeRate_chain", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_ExchangeRate,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRate_chain" "', argument " "1"" of type '" "ExchangeRate const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRate_chain" "', argument " "1"" of type '" "ExchangeRate const &""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ExchangeRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRate_chain" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRate_chain" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  arg2 = reinterpret_cast< ExchangeRate * >(argp2);
  {
    try {
      result = ExchangeRate::chain((ExchangeRate const &)*arg1,(ExchangeRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ExchangeRate(result)), SWIGTYPE_p_ExchangeRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExchangeRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRate *arg1 = (ExchangeRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExchangeRate" "', argument " "1"" of type '" "ExchangeRate *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRate * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExchangeRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ExchangeRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExchangeRate_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ExchangeRateManager_instance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRateManager *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ExchangeRateManager_instance", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (ExchangeRateManager *) &ExchangeRateManager::instance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  ExchangeRate *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRateManager_add" "', argument " "1"" of type '" "ExchangeRateManager *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ExchangeRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRateManager_add" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_add" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  arg2 = reinterpret_cast< ExchangeRate * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExchangeRateManager_add" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_add" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExchangeRateManager_add" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_add" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      (arg1)->add((ExchangeRate const &)*arg2,(Date const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  ExchangeRate *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRateManager_add" "', argument " "1"" of type '" "ExchangeRateManager *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ExchangeRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRateManager_add" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_add" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  arg2 = reinterpret_cast< ExchangeRate * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExchangeRateManager_add" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_add" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      (arg1)->add((ExchangeRate const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  ExchangeRate *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRateManager_add" "', argument " "1"" of type '" "ExchangeRateManager *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ExchangeRate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRateManager_add" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_add" "', argument " "2"" of type '" "ExchangeRate const &""'"); 
  }
  arg2 = reinterpret_cast< ExchangeRate * >(argp2);
  {
    try {
      (arg1)->add((ExchangeRate const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ExchangeRateManager_add", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ExchangeRateManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ExchangeRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ExchangeRateManager_add__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ExchangeRateManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ExchangeRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ExchangeRateManager_add__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ExchangeRateManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ExchangeRate, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ExchangeRateManager_add__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ExchangeRateManager_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExchangeRateManager::add(ExchangeRate const &,Date const &,Date const &)\n"
    "    ExchangeRateManager::add(ExchangeRate const &,Date const &)\n"
    "    ExchangeRateManager::add(ExchangeRate const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_lookup__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  Currency *arg2 = 0 ;
  Currency *arg3 = 0 ;
  Date *arg4 = 0 ;
  ExchangeRate::Type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< ExchangeRate > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRateManager_lookup" "', argument " "1"" of type '" "ExchangeRateManager const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRateManager_lookup" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_lookup" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  arg2 = reinterpret_cast< Currency * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExchangeRateManager_lookup" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_lookup" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  arg3 = reinterpret_cast< Currency * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExchangeRateManager_lookup" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_lookup" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ExchangeRateManager_lookup" "', argument " "5"" of type '" "ExchangeRate::Type""'");
  } 
  arg5 = static_cast< ExchangeRate::Type >(val5);
  {
    try {
      result = ((ExchangeRateManager const *)arg1)->lookup((Currency const &)*arg2,(Currency const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ExchangeRate(result)), SWIGTYPE_p_ExchangeRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_lookup__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  Currency *arg2 = 0 ;
  Currency *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SwigValueWrapper< ExchangeRate > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRateManager_lookup" "', argument " "1"" of type '" "ExchangeRateManager const *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExchangeRateManager_lookup" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_lookup" "', argument " "2"" of type '" "Currency const &""'"); 
  }
  arg2 = reinterpret_cast< Currency * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Currency,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExchangeRateManager_lookup" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_lookup" "', argument " "3"" of type '" "Currency const &""'"); 
  }
  arg3 = reinterpret_cast< Currency * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExchangeRateManager_lookup" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExchangeRateManager_lookup" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = ((ExchangeRateManager const *)arg1)->lookup((Currency const &)*arg2,(Currency const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new ExchangeRate(result)), SWIGTYPE_p_ExchangeRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_lookup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ExchangeRateManager_lookup", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ExchangeRateManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ExchangeRateManager_lookup__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ExchangeRateManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Currency, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExchangeRateManager_lookup__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ExchangeRateManager_lookup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExchangeRateManager::lookup(Currency const &,Currency const &,Date const &,ExchangeRate::Type) const\n"
    "    ExchangeRateManager::lookup(Currency const &,Currency const &,Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ExchangeRateManager_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExchangeRateManager_clear" "', argument " "1"" of type '" "ExchangeRateManager *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExchangeRateManager(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExchangeRateManager *arg1 = (ExchangeRateManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExchangeRateManager, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExchangeRateManager" "', argument " "1"" of type '" "ExchangeRateManager *""'"); 
  }
  arg1 = reinterpret_cast< ExchangeRateManager * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExchangeRateManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ExchangeRateManager, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Settings_instance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Settings_instance", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Settings *) &Settings::instance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getEvaluationDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getEvaluationDate" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  {
    try {
      result = Settings_getEvaluationDate(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_setEvaluationDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Settings_setEvaluationDate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_setEvaluationDate" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_setEvaluationDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Settings_setEvaluationDate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      Settings_setEvaluationDate(arg1,(Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_includeReferenceDateEvents(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Settings_includeReferenceDateEvents", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_includeReferenceDateEvents" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Settings_includeReferenceDateEvents" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      Settings_includeReferenceDateEvents(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_includeTodaysCashFlows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Settings_includeTodaysCashFlows", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_includeTodaysCashFlows" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Settings_includeTodaysCashFlows" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      Settings_includeTodaysCashFlows(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_setEnforcesTodaysHistoricFixings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Settings_setEnforcesTodaysHistoricFixings", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_setEnforcesTodaysHistoricFixings" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Settings_setEnforcesTodaysHistoricFixings" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      Settings_setEnforcesTodaysHistoricFixings(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getEnforcesTodaysHistoricFixings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getEnforcesTodaysHistoricFixings" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  {
    try {
      result = (bool)Settings_getEnforcesTodaysHistoricFixings(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Settings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settings *arg1 = (Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Settings" "', argument " "1"" of type '" "Settings *""'"); 
  }
  arg1 = reinterpret_cast< Settings * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Settings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Settings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Fdm1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  Fdm1dMesher *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fdm1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (Fdm1dMesher *)new Fdm1dMesher(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1dMesher > *smartresult = result ? new ext::shared_ptr<  Fdm1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesher_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher const > tempshared1 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesher_size" "', argument " "1"" of type '" "Fdm1dMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Fdm1dMesher const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesher_dplus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher const > tempshared1 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesher_dplus", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesher_dplus" "', argument " "1"" of type '" "Fdm1dMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesher_dplus" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)((Fdm1dMesher const *)arg1)->dplus(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesher_dminus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher const > tempshared1 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesher_dminus", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesher_dminus" "', argument " "1"" of type '" "Fdm1dMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesher_dminus" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)((Fdm1dMesher const *)arg1)->dminus(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesher_location(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher const > tempshared1 ;
  ext::shared_ptr< Fdm1dMesher const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesher_location", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesher_location" "', argument " "1"" of type '" "Fdm1dMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesher_location" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)((Fdm1dMesher const *)arg1)->location(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesher_locations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared1 ;
  ext::shared_ptr< Fdm1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesher_locations" "', argument " "1"" of type '" "Fdm1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &(arg1)->locations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = (Fdm1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared1 ;
  ext::shared_ptr< Fdm1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm1dMesher" "', argument " "1"" of type '" "Fdm1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____bool__((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____len__((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm1dMesherVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *ptr = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fdm1dMesherVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm1dMesherVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Fdm1dMesherVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Fdm1dMesherVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__setslice__(std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__setslice__(std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type,std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type,std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm1dMesherVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *ptr = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm1dMesherVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Fdm1dMesherVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Fdm1dMesherVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__delitem__(std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1dMesher > *smartresult = *result ? new ext::shared_ptr<  Fdm1dMesher >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Fdm1dMesherVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Fdm1dMesherVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__getitem__(std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fdm1dMesherVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Fdm1dMesher > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Fdm1dMesherVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Fdm1dMesherVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Fdm1dMesherVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::__setitem__(std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1dMesher > *smartresult = result ? new ext::shared_ptr<  Fdm1dMesher >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm1dMesherVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__append(arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm1dMesherVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)new std::vector< ext::shared_ptr< Fdm1dMesher > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm1dMesherVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *ptr = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm1dMesherVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm1dMesherVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)new std::vector< ext::shared_ptr< Fdm1dMesher > >((std::vector< ext::shared_ptr< Fdm1dMesher > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm1dMesherVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm1dMesherVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< Fdm1dMesher > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< Fdm1dMesher > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm1dMesherVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fdm1dMesherVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)new std::vector< ext::shared_ptr< Fdm1dMesher > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Fdm1dMesherVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Fdm1dMesherVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::erase(std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::erase(std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator,std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Fdm1dMesherVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg1 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Fdm1dMesherVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm1dMesherVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > > *)new std::vector< ext::shared_ptr< Fdm1dMesher > >(arg1,(std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm1dMesherVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fdm1dMesherVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Fdm1dMesherVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Fdm1dMesherVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Fdm1dMesherVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Fdm1dMesherVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fdm1dMesherVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::vector()\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::vector(std::vector< ext::shared_ptr< Fdm1dMesher > > const &)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::vector(std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::vector(std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm1dMesherVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *) &((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1dMesher > *smartresult = *result ? new ext::shared_ptr<  Fdm1dMesher >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *) &((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1dMesher > *smartresult = *result ? new ext::shared_ptr<  Fdm1dMesher >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fdm1dMesherVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fdm1dMesherVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Fdm1dMesherVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Fdm1dMesherVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::resize(std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::resize(std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Fdm1dMesherVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< Fdm1dMesher > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator arg2 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg3 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Fdm1dMesherVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm1dMesherVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Fdm1dMesherVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_Fdm1dMesher_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< Fdm1dMesher > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Fdm1dMesherVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Fdm1dMesherVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Fdm1dMesherVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::insert(std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< Fdm1dMesher > >::insert(std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator,std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type,std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1dMesherVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1dMesherVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1dMesherVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1dMesherVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< Fdm1dMesher > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm1dMesherVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher > > *arg1 = (std::vector< ext::shared_ptr< Fdm1dMesher > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm1dMesherVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< Fdm1dMesher > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm1dMesherVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_Fdm1dMesher_t_std__allocatorT_ext__shared_ptrT_Fdm1dMesher_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm1dMesherVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmBlackScholesMesher(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  doubleOrNull arg5 = (doubleOrNull) Null< Real >() ;
  doubleOrNull arg6 = (doubleOrNull) Null< Real >() ;
  Real arg7 = (Real) 0.0001 ;
  Real arg8 = (Real) 1.5 ;
  std::pair< Real,Real > const &arg9_defvalue = (std::pair< Real,Real >(Null<Real>(), Null<Real>())) ;
  std::pair< Real,Real > *arg9 = (std::pair< Real,Real > *) &arg9_defvalue ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &arg10_defvalue = std::vector< ext::shared_ptr< Dividend > >() ;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg10 = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *) &arg10_defvalue ;
  ext::shared_ptr< FdmQuantoHelper > const &arg11_defvalue = ext::shared_ptr< FdmQuantoHelper >() ;
  ext::shared_ptr< FdmQuantoHelper > *arg11 = (ext::shared_ptr< FdmQuantoHelper > *) &arg11_defvalue ;
  Real arg12 = (Real) 0.0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  void *argp11 ;
  int res11 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared11 ;
  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 ;
  char * kwnames[] = {
    (char *)"size",  (char *)"process",  (char *)"maturity",  (char *)"strike",  (char *)"xMinConstraint",  (char *)"xMaxConstraint",  (char *)"eps",  (char *)"scaleFactor",  (char *)"cPoint",  (char *)"dividendSchedule",  (char *)"fdmQuantoHelper",  (char *)"spotAdjustment",  NULL 
  };
  FdmBlackScholesMesher *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOOOO:new_FdmBlackScholesMesher", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmBlackScholesMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesMesher" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesMesher" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  if (obj4) {
    {
      if (obj4 == Py_None)
      arg5 = Null<double>();
      else if (PyFloat_Check(obj4))
      arg5 = PyFloat_AsDouble(obj4);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj5) {
    {
      if (obj5 == Py_None)
      arg6 = Null<double>();
      else if (PyFloat_Check(obj5))
      arg6 = PyFloat_AsDouble(obj5);
      else
      SWIG_exception(SWIG_TypeError,"double expected");
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdmBlackScholesMesher" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FdmBlackScholesMesher" "', argument " "8"" of type '" "Real""'");
    } 
    arg8 = static_cast< Real >(val8);
  }
  if (obj8) {
    {
      std::pair< double,double > *ptr = (std::pair< double,double > *)0;
      res9 = swig::asptr(obj8, &ptr);
      if (!SWIG_IsOK(res9)) {
        SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_FdmBlackScholesMesher" "', argument " "9"" of type '" "std::pair< Real,Real > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBlackScholesMesher" "', argument " "9"" of type '" "std::pair< Real,Real > const &""'"); 
      }
      arg9 = ptr;
    }
  }
  if (obj9) {
    {
      std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
      res10 = swig::asptr(obj9, &ptr);
      if (!SWIG_IsOK(res10)) {
        SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FdmBlackScholesMesher" "', argument " "10"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBlackScholesMesher" "', argument " "10"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
      }
      arg10 = ptr;
    }
  }
  if (obj10) {
    {
      int newmem = 0;
      res11 = SWIG_ConvertPtrAndOwn(obj10, &argp11, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
      if (!SWIG_IsOK(res11)) {
        SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_FdmBlackScholesMesher" "', argument " "11"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp11) tempshared11 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp11);
        delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp11);
        arg11 = &tempshared11;
      } else {
        arg11 = (argp11) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp11) : &tempshared11;
      }
    }
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_double(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FdmBlackScholesMesher" "', argument " "12"" of type '" "Real""'");
    } 
    arg12 = static_cast< Real >(val12);
  }
  {
    try {
      result = (FdmBlackScholesMesher *)new FdmBlackScholesMesher(arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::pair< Real,Real > const &)*arg9,(std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg10,(ext::shared_ptr< FdmQuantoHelper > const &)*arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesMesher > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBlackScholesMesher_processHelper(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< Quote > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBlackScholesMesher_processHelper", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "1"" of type '" "Handle< Quote > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< Quote > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmBlackScholesMesher_processHelper" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  {
    try {
      result = FdmBlackScholesMesher::processHelper((Handle< Quote > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GeneralizedBlackScholesProcess > *smartresult = result ? new ext::shared_ptr<  GeneralizedBlackScholesProcess >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmBlackScholesMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBlackScholesMesher *arg1 = (FdmBlackScholesMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBlackScholesMesher > tempshared1 ;
  ext::shared_ptr< FdmBlackScholesMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBlackScholesMesher" "', argument " "1"" of type '" "FdmBlackScholesMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBlackScholesMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBlackScholesMesher > * >(argp1);
      arg1 = const_cast< FdmBlackScholesMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBlackScholesMesher > * >(argp1);
      arg1 = const_cast< FdmBlackScholesMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBlackScholesMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBlackScholesMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Concentrating1dMesherPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  bool arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  ext::tuple< Real,Real,bool > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Concentrating1dMesherPoint", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesherPoint" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Concentrating1dMesherPoint" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Concentrating1dMesherPoint" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (ext::tuple< Real,Real,bool > *)new ext::tuple< Real,Real,bool >(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPoint_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_bool_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPoint_first" "', argument " "1"" of type '" "ext::tuple< Real,Real,bool > const *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,bool > * >(argp1);
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__first((ext::tuple< double,double,bool > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPoint_second(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_bool_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPoint_second" "', argument " "1"" of type '" "ext::tuple< Real,Real,bool > const *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,bool > * >(argp1);
  {
    try {
      result = (double)ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__second((ext::tuple< double,double,bool > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPoint_third(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_bool_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPoint_third" "', argument " "1"" of type '" "ext::tuple< Real,Real,bool > const *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,bool > * >(argp1);
  {
    try {
      result = (bool)ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__third((ext::tuple< double,double,bool > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Concentrating1dMesherPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::tuple< Real,Real,bool > *arg1 = (ext::tuple< Real,Real,bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Concentrating1dMesherPoint" "', argument " "1"" of type '" "ext::tuple< Real,Real,bool > *""'"); 
  }
  arg1 = reinterpret_cast< ext::tuple< Real,Real,bool > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Concentrating1dMesherPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Concentrating1dMesherPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_iterator" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____nonzero__((std::vector< ext::tuple< double,double,bool > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___bool__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____bool__((std::vector< ext::tuple< double,double,bool > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::tuple< double,double,bool > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___len__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____len__((std::vector< ext::tuple< double,double,bool > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Concentrating1dMesherPointVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg3 ;
  std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val3);
  {
    std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *ptr = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::tuple< double,double,bool >,std::allocator< ext::tuple< double,double,bool > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Concentrating1dMesherPointVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Concentrating1dMesherPointVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__setslice__(std::vector< ext::tuple< double,double,bool > >::difference_type,std::vector< ext::tuple< double,double,bool > >::difference_type)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__setslice__(std::vector< ext::tuple< double,double,bool > >::difference_type,std::vector< ext::tuple< double,double,bool > >::difference_type,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Concentrating1dMesherPointVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *ptr = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::tuple< double,double,bool >,std::allocator< ext::tuple< double,double,bool > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__delitem__(std::vector< ext::tuple< double,double,bool > >::difference_type)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::tuple< double,double,bool > >::value_type *) &std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____getitem____SWIG_1((std::vector< ext::tuple< double,double,bool > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ext__tupleT_double_double_bool_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< ext::tuple< double,double,bool > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__getitem__(std::vector< ext::tuple< double,double,bool > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::difference_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::tuple< double,double,bool > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Concentrating1dMesherPointVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Concentrating1dMesherPointVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::__setitem__(std::vector< ext::tuple< double,double,bool > >::difference_type,std::vector< ext::tuple< double,double,bool > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< ext::tuple< double,double,bool > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_pop" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::tuple< double,double,bool > >::value_type(result)), SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_append" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Concentrating1dMesherPointVector_append" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_append" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__append(arg1,(ext::tuple< double,double,bool > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesherPointVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::tuple< Real,Real,bool > > *)new std::vector< ext::tuple< Real,Real,bool > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesherPointVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *ptr = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Concentrating1dMesherPointVector" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concentrating1dMesherPointVector" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::tuple< Real,Real,bool > > *)new std::vector< ext::tuple< Real,Real,bool > >((std::vector< ext::tuple< Real,Real,bool > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_empty" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::tuple< Real,Real,bool > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::tuple< double,double,bool > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_size" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::tuple< Real,Real,bool > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< Real,Real,bool > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_swap" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Concentrating1dMesherPointVector_swap" "', argument " "2"" of type '" "std::vector< ext::tuple< Real,Real,bool > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_swap" "', argument " "2"" of type '" "std::vector< ext::tuple< Real,Real,bool > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_begin" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_end" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_rend" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_clear" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::tuple< double,double,bool > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::tuple< Real,Real,bool > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::tuple< double,double,bool > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__tupleT_Real_Real_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesherPointVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< double,double,bool > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesherPointVector" "', argument " "1"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::tuple< Real,Real,bool > > *)new std::vector< ext::tuple< Real,Real,bool > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_resize" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector_resize" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > arg2 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_erase" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Concentrating1dMesherPointVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::erase(std::vector< ext::tuple< double,double,bool > >::iterator)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::erase(std::vector< ext::tuple< double,double,bool > >::iterator,std::vector< ext::tuple< double,double,bool > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesherPointVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< double,double,bool > >::size_type arg1 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< ext::tuple< Real,Real,bool > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesherPointVector" "', argument " "1"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Concentrating1dMesherPointVector" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concentrating1dMesherPointVector" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp2);
  {
    try {
      result = (std::vector< ext::tuple< Real,Real,bool > > *)new std::vector< ext::tuple< Real,Real,bool > >(arg1,(std::vector< ext::tuple< double,double,bool > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesherPointVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Concentrating1dMesherPointVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Concentrating1dMesherPointVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Concentrating1dMesherPointVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Concentrating1dMesherPointVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Concentrating1dMesherPointVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Concentrating1dMesherPointVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::vector()\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::vector(std::vector< ext::tuple< Real,Real,bool > > const &)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::vector(std::vector< ext::tuple< double,double,bool > >::size_type)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::vector(std::vector< ext::tuple< double,double,bool > >::size_type,std::vector< ext::tuple< double,double,bool > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_push_back" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Concentrating1dMesherPointVector_push_back" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_push_back" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< ext::tuple< double,double,bool > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::tuple< double,double,bool > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_front" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (std::vector< ext::tuple< double,double,bool > >::value_type *) &((std::vector< ext::tuple< Real,Real,bool > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ext__tupleT_double_double_bool_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< ext::tuple< double,double,bool > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::tuple< double,double,bool > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_back" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = (std::vector< ext::tuple< double,double,bool > >::value_type *) &((std::vector< ext::tuple< Real,Real,bool > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ext__tupleT_double_double_bool_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< ext::tuple< double,double,bool > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_assign" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector_assign" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Concentrating1dMesherPointVector_assign" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_assign" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::tuple< double,double,bool > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type arg2 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_resize" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector_resize" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Concentrating1dMesherPointVector_resize" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_resize" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::tuple< double,double,bool > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Concentrating1dMesherPointVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Concentrating1dMesherPointVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::resize(std::vector< ext::tuple< double,double,bool > >::size_type)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::resize(std::vector< ext::tuple< double,double,bool > >::size_type,std::vector< ext::tuple< double,double,bool > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > arg2 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::tuple< double,double,bool > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::tuple< double,double,bool > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  SwigValueWrapper< std::vector< ext::tuple< double,double,bool > >::iterator > arg2 ;
  std::vector< ext::tuple< double,double,bool > >::size_type arg3 ;
  std::vector< ext::tuple< double,double,bool > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "3"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_ext__tupleT_double_double_bool_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "4"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Concentrating1dMesherPointVector_insert" "', argument " "4"" of type '" "std::vector< ext::tuple< double,double,bool > >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< ext::tuple< double,double,bool > >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_ext_tuple_Sl_Real_Sc_Real_Sc_bool_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::tuple< double,double,bool > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Concentrating1dMesherPointVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::tuple< double,double,bool > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__tupleT_double_double_bool_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Concentrating1dMesherPointVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Concentrating1dMesherPointVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::insert(std::vector< ext::tuple< double,double,bool > >::iterator,std::vector< ext::tuple< double,double,bool > >::value_type const &)\n"
    "    std::vector< ext::tuple< Real,Real,bool > >::insert(std::vector< ext::tuple< double,double,bool > >::iterator,std::vector< ext::tuple< double,double,bool > >::size_type,std::vector< ext::tuple< double,double,bool > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  std::vector< ext::tuple< double,double,bool > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Concentrating1dMesherPointVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_reserve" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Concentrating1dMesherPointVector_reserve" "', argument " "2"" of type '" "std::vector< ext::tuple< double,double,bool > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::tuple< double,double,bool > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Concentrating1dMesherPointVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::tuple< double,double,bool > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Concentrating1dMesherPointVector_capacity" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::tuple< Real,Real,bool > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Concentrating1dMesherPointVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::tuple< Real,Real,bool > > *arg1 = (std::vector< ext::tuple< Real,Real,bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Concentrating1dMesherPointVector" "', argument " "1"" of type '" "std::vector< ext::tuple< Real,Real,bool > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::tuple< Real,Real,bool > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Concentrating1dMesherPointVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__tupleT_Real_Real_bool_t_std__allocatorT_ext__tupleT_Real_Real_bool_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Concentrating1dMesherPointVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Concentrating1dMesher__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::pair< Real,Real > *arg4 = 0 ;
  bool arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  Concentrating1dMesher *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesher" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Concentrating1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Concentrating1dMesher" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::pair< Real,Real > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::pair< Real,Real > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Concentrating1dMesher" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::pair< Real,Real > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Concentrating1dMesher > *smartresult = result ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesher__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::pair< Real,Real > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Concentrating1dMesher *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesher" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Concentrating1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Concentrating1dMesher" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::pair< Real,Real > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::pair< Real,Real > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::pair< Real,Real > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Concentrating1dMesher > *smartresult = result ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesher__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Concentrating1dMesher *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesher" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Concentrating1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Concentrating1dMesher" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Concentrating1dMesher > *smartresult = result ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesher__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *arg4 = 0 ;
  Real arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  Concentrating1dMesher *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesher" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Concentrating1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Concentrating1dMesher" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *ptr = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Concentrating1dMesher" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Concentrating1dMesher > *smartresult = result ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesher__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Concentrating1dMesher *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Concentrating1dMesher" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Concentrating1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Concentrating1dMesher" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *ptr = (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concentrating1dMesher" "', argument " "4"" of type '" "std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (Concentrating1dMesher *)new Concentrating1dMesher(arg1,arg2,arg3,(std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Concentrating1dMesher > *smartresult = result ? new ext::shared_ptr<  Concentrating1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concentrating1dMesher(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Concentrating1dMesher", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Concentrating1dMesher__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< double,double >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Concentrating1dMesher__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Concentrating1dMesher__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< double,double >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Concentrating1dMesher__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Concentrating1dMesher__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Concentrating1dMesher'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Concentrating1dMesher::Concentrating1dMesher(Real,Real,Size,std::pair< Real,Real > const &,bool const)\n"
    "    Concentrating1dMesher::Concentrating1dMesher(Real,Real,Size,std::pair< Real,Real > const &)\n"
    "    Concentrating1dMesher::Concentrating1dMesher(Real,Real,Size)\n"
    "    Concentrating1dMesher::Concentrating1dMesher(Real,Real,Size,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &,Real)\n"
    "    Concentrating1dMesher::Concentrating1dMesher(Real,Real,Size,std::vector< ext::tuple< Real,Real,bool >,std::allocator< ext::tuple< Real,Real,bool > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Concentrating1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Concentrating1dMesher *arg1 = (Concentrating1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Concentrating1dMesher > tempshared1 ;
  ext::shared_ptr< Concentrating1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Concentrating1dMesher" "', argument " "1"" of type '" "Concentrating1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Concentrating1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Concentrating1dMesher > * >(argp1);
      arg1 = const_cast< Concentrating1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Concentrating1dMesher > * >(argp1);
      arg1 = const_cast< Concentrating1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Concentrating1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Concentrating1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Concentrating1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExponentialJump1dMesher__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  ExponentialJump1dMesher *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialJump1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialJump1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExponentialJump1dMesher" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialJump1dMesher" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExponentialJump1dMesher" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (ExponentialJump1dMesher *)new ExponentialJump1dMesher(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialJump1dMesher > *smartresult = result ? new ext::shared_ptr<  ExponentialJump1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialJump1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialJump1dMesher__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  ExponentialJump1dMesher *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialJump1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialJump1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExponentialJump1dMesher" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialJump1dMesher" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (ExponentialJump1dMesher *)new ExponentialJump1dMesher(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialJump1dMesher > *smartresult = result ? new ext::shared_ptr<  ExponentialJump1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialJump1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialJump1dMesher(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExponentialJump1dMesher", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ExponentialJump1dMesher__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ExponentialJump1dMesher__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExponentialJump1dMesher'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExponentialJump1dMesher::ExponentialJump1dMesher(Size,Real,Real,Real,Real)\n"
    "    ExponentialJump1dMesher::ExponentialJump1dMesher(Size,Real,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExponentialJump1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExponentialJump1dMesher *arg1 = (ExponentialJump1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExponentialJump1dMesher > tempshared1 ;
  ext::shared_ptr< ExponentialJump1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExponentialJump1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExponentialJump1dMesher" "', argument " "1"" of type '" "ExponentialJump1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExponentialJump1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExponentialJump1dMesher > * >(argp1);
      arg1 = const_cast< ExponentialJump1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExponentialJump1dMesher > * >(argp1);
      arg1 = const_cast< ExponentialJump1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExponentialJump1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExponentialJump1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExponentialJump1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmCEV1dMesher(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Time arg5 ;
  Real arg6 = (Real) 0.0001 ;
  Real arg7 = (Real) 1.5 ;
  std::pair< Real,Real > const &arg8_defvalue = (std::pair< Real,Real >(Null<Real>(), Null<Real>())) ;
  std::pair< Real,Real > *arg8 = (std::pair< Real,Real > *) &arg8_defvalue ;
  size_t 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 ;
  int res8 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"size",  (char *)"f0",  (char *)"alpha",  (char *)"beta",  (char *)"maturity",  (char *)"eps",  (char *)"scaleFactor",  (char *)"cPoint",  NULL 
  };
  FdmCEV1dMesher *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOO:new_FdmCEV1dMesher", kwnames, &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 '" "new_FdmCEV1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmCEV1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmCEV1dMesher" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmCEV1dMesher" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmCEV1dMesher" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_double(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmCEV1dMesher" "', argument " "6"" of type '" "Real""'");
    } 
    arg6 = static_cast< Real >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdmCEV1dMesher" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    {
      std::pair< double,double > *ptr = (std::pair< double,double > *)0;
      res8 = swig::asptr(obj7, &ptr);
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FdmCEV1dMesher" "', argument " "8"" of type '" "std::pair< Real,Real > const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmCEV1dMesher" "', argument " "8"" of type '" "std::pair< Real,Real > const &""'"); 
      }
      arg8 = ptr;
    }
  }
  {
    try {
      result = (FdmCEV1dMesher *)new FdmCEV1dMesher(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(std::pair< Real,Real > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmCEV1dMesher > *smartresult = result ? new ext::shared_ptr<  FdmCEV1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmCEV1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmCEV1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmCEV1dMesher *arg1 = (FdmCEV1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmCEV1dMesher > tempshared1 ;
  ext::shared_ptr< FdmCEV1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmCEV1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmCEV1dMesher" "', argument " "1"" of type '" "FdmCEV1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmCEV1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmCEV1dMesher > * >(argp1);
      arg1 = const_cast< FdmCEV1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmCEV1dMesher > * >(argp1);
      arg1 = const_cast< FdmCEV1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmCEV1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmCEV1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmCEV1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonVarianceMesher__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  Real arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  FdmHestonVarianceMesher *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmHestonVarianceMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonVarianceMesher" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonVarianceMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmHestonVarianceMesher" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmHestonVarianceMesher" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FdmHestonVarianceMesher *)new FdmHestonVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonVarianceMesher > *smartresult = result ? new ext::shared_ptr<  FdmHestonVarianceMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonVarianceMesher__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdmHestonVarianceMesher *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmHestonVarianceMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonVarianceMesher" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonVarianceMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmHestonVarianceMesher" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdmHestonVarianceMesher *)new FdmHestonVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonVarianceMesher > *smartresult = result ? new ext::shared_ptr<  FdmHestonVarianceMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonVarianceMesher__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  Time arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  FdmHestonVarianceMesher *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmHestonVarianceMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonVarianceMesher" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonVarianceMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (FdmHestonVarianceMesher *)new FdmHestonVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonVarianceMesher > *smartresult = result ? new ext::shared_ptr<  FdmHestonVarianceMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonVarianceMesher(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmHestonVarianceMesher", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmHestonVarianceMesher__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmHestonVarianceMesher__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdmHestonVarianceMesher__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmHestonVarianceMesher'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmHestonVarianceMesher::FdmHestonVarianceMesher(Size,ext::shared_ptr< HestonProcess > const &,Time,Size,Real)\n"
    "    FdmHestonVarianceMesher::FdmHestonVarianceMesher(Size,ext::shared_ptr< HestonProcess > const &,Time,Size)\n"
    "    FdmHestonVarianceMesher::FdmHestonVarianceMesher(Size,ext::shared_ptr< HestonProcess > const &,Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmHestonVarianceMesher_volaEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonVarianceMesher *arg1 = (FdmHestonVarianceMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonVarianceMesher const > tempshared1 ;
  ext::shared_ptr< FdmHestonVarianceMesher const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonVarianceMesher_volaEstimate" "', argument " "1"" of type '" "FdmHestonVarianceMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonVarianceMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonVarianceMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonVarianceMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((FdmHestonVarianceMesher const *)arg1)->volaEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonVarianceMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonVarianceMesher *arg1 = (FdmHestonVarianceMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonVarianceMesher > tempshared1 ;
  ext::shared_ptr< FdmHestonVarianceMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonVarianceMesher" "', argument " "1"" of type '" "FdmHestonVarianceMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonVarianceMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonVarianceMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonVarianceMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonVarianceMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonVarianceMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonVarianceMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg3 = 0 ;
  Time arg4 ;
  Size arg5 ;
  Real arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  FdmHestonLocalVolatilityVarianceMesher *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "3"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (FdmHestonLocalVolatilityVarianceMesher *)new FdmHestonLocalVolatilityVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< LocalVolTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > *smartresult = result ? new ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg3 = 0 ;
  Time arg4 ;
  Size arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdmHestonLocalVolatilityVarianceMesher *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "3"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdmHestonLocalVolatilityVarianceMesher *)new FdmHestonLocalVolatilityVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< LocalVolTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > *smartresult = result ? new ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg3 = 0 ;
  Time arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  FdmHestonLocalVolatilityVarianceMesher *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "3"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmHestonLocalVolatilityVarianceMesher" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (FdmHestonLocalVolatilityVarianceMesher *)new FdmHestonLocalVolatilityVarianceMesher(arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< LocalVolTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > *smartresult = result ? new ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonLocalVolatilityVarianceMesher(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmHestonLocalVolatilityVarianceMesher", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdmHestonLocalVolatilityVarianceMesher__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmHestonLocalVolatilityVarianceMesher'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmHestonLocalVolatilityVarianceMesher::FdmHestonLocalVolatilityVarianceMesher(Size,ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< LocalVolTermStructure > const &,Time,Size,Real)\n"
    "    FdmHestonLocalVolatilityVarianceMesher::FdmHestonLocalVolatilityVarianceMesher(Size,ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< LocalVolTermStructure > const &,Time,Size)\n"
    "    FdmHestonLocalVolatilityVarianceMesher::FdmHestonLocalVolatilityVarianceMesher(Size,ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< LocalVolTermStructure > const &,Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmHestonLocalVolatilityVarianceMesher_volaEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonLocalVolatilityVarianceMesher *arg1 = (FdmHestonLocalVolatilityVarianceMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher const > tempshared1 ;
  ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonLocalVolatilityVarianceMesher_volaEstimate" "', argument " "1"" of type '" "FdmHestonLocalVolatilityVarianceMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonLocalVolatilityVarianceMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonLocalVolatilityVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonLocalVolatilityVarianceMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonLocalVolatilityVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonLocalVolatilityVarianceMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((FdmHestonLocalVolatilityVarianceMesher const *)arg1)->volaEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonLocalVolatilityVarianceMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonLocalVolatilityVarianceMesher *arg1 = (FdmHestonLocalVolatilityVarianceMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher > tempshared1 ;
  ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonLocalVolatilityVarianceMesher" "', argument " "1"" of type '" "FdmHestonLocalVolatilityVarianceMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonLocalVolatilityVarianceMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonLocalVolatilityVarianceMesher > * >(argp1);
      arg1 = const_cast< FdmHestonLocalVolatilityVarianceMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonLocalVolatilityVarianceMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonLocalVolatilityVarianceMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSimpleProcess1dMesher__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  Real arg5 ;
  doubleOrNull arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "2"" of type '" "ext::shared_ptr< StochasticProcess1D > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    if (swig_obj[5] == Py_None)
    arg6 = Null<double>();
    else if (PyFloat_Check(swig_obj[5]))
    arg6 = PyFloat_AsDouble(swig_obj[5]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleProcess1dMesher > *smartresult = result ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSimpleProcess1dMesher__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  Real arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "2"" of type '" "ext::shared_ptr< StochasticProcess1D > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleProcess1dMesher > *smartresult = result ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSimpleProcess1dMesher__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  Size arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "2"" of type '" "ext::shared_ptr< StochasticProcess1D > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleProcess1dMesher > *smartresult = result ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSimpleProcess1dMesher__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< StochasticProcess1D > *arg2 = 0 ;
  Time arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StochasticProcess1D > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  FdmSimpleProcess1dMesher *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "2"" of type '" "ext::shared_ptr< StochasticProcess1D > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StochasticProcess1D > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSimpleProcess1dMesher" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (FdmSimpleProcess1dMesher *)new FdmSimpleProcess1dMesher(arg1,(ext::shared_ptr< StochasticProcess1D > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleProcess1dMesher > *smartresult = result ? new ext::shared_ptr<  FdmSimpleProcess1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSimpleProcess1dMesher(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmSimpleProcess1dMesher", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmSimpleProcess1dMesher__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmSimpleProcess1dMesher__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdmSimpleProcess1dMesher__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = (argv[5] == Py_None || PyFloat_Check(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_new_FdmSimpleProcess1dMesher__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmSimpleProcess1dMesher'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmSimpleProcess1dMesher::FdmSimpleProcess1dMesher(Size,ext::shared_ptr< StochasticProcess1D > const &,Time,Size,Real,doubleOrNull)\n"
    "    FdmSimpleProcess1dMesher::FdmSimpleProcess1dMesher(Size,ext::shared_ptr< StochasticProcess1D > const &,Time,Size,Real)\n"
    "    FdmSimpleProcess1dMesher::FdmSimpleProcess1dMesher(Size,ext::shared_ptr< StochasticProcess1D > const &,Time,Size)\n"
    "    FdmSimpleProcess1dMesher::FdmSimpleProcess1dMesher(Size,ext::shared_ptr< StochasticProcess1D > const &,Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmSimpleProcess1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSimpleProcess1dMesher *arg1 = (FdmSimpleProcess1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSimpleProcess1dMesher > tempshared1 ;
  ext::shared_ptr< FdmSimpleProcess1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSimpleProcess1dMesher" "', argument " "1"" of type '" "FdmSimpleProcess1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmSimpleProcess1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmSimpleProcess1dMesher > * >(argp1);
      arg1 = const_cast< FdmSimpleProcess1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmSimpleProcess1dMesher > * >(argp1);
      arg1 = const_cast< FdmSimpleProcess1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSimpleProcess1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSimpleProcess1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Uniform1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Size arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Uniform1dMesher *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Uniform1dMesher", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Uniform1dMesher" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Uniform1dMesher" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Uniform1dMesher" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Uniform1dMesher *)new Uniform1dMesher(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Uniform1dMesher > *smartresult = result ? new ext::shared_ptr<  Uniform1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Uniform1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Uniform1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Uniform1dMesher *arg1 = (Uniform1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Uniform1dMesher > tempshared1 ;
  ext::shared_ptr< Uniform1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Uniform1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Uniform1dMesher" "', argument " "1"" of type '" "Uniform1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Uniform1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Uniform1dMesher > * >(argp1);
      arg1 = const_cast< Uniform1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Uniform1dMesher > * >(argp1);
      arg1 = const_cast< Uniform1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Uniform1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Uniform1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Uniform1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Predefined1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  Predefined1dMesher *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Predefined1dMesher" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Predefined1dMesher" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (Predefined1dMesher *)new Predefined1dMesher((std::vector< Real,std::allocator< Real > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Predefined1dMesher > *smartresult = result ? new ext::shared_ptr<  Predefined1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Predefined1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Predefined1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Predefined1dMesher *arg1 = (Predefined1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Predefined1dMesher > tempshared1 ;
  ext::shared_ptr< Predefined1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Predefined1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Predefined1dMesher" "', argument " "1"" of type '" "Predefined1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Predefined1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Predefined1dMesher > * >(argp1);
      arg1 = const_cast< Predefined1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Predefined1dMesher > * >(argp1);
      arg1 = const_cast< Predefined1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Predefined1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Predefined1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Predefined1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Glued1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1dMesher *arg1 = 0 ;
  Fdm1dMesher *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher const > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< Fdm1dMesher const > tempshared2 ;
  PyObject *swig_obj[2] ;
  Glued1dMesher *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Glued1dMesher", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Glued1dMesher" "', argument " "1"" of type '" "Fdm1dMesher const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Glued1dMesher" "', argument " "1"" of type '" "Fdm1dMesher const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1);
      arg1 = const_cast< Fdm1dMesher * >(tempshared1.get());
    } else {
      arg1 = const_cast< Fdm1dMesher * >(reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp1)->get());
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Glued1dMesher" "', argument " "2"" of type '" "Fdm1dMesher const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Glued1dMesher" "', argument " "2"" of type '" "Fdm1dMesher const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp2);
      arg2 = const_cast< Fdm1dMesher * >(tempshared2.get());
    } else {
      arg2 = const_cast< Fdm1dMesher * >(reinterpret_cast< ext::shared_ptr< const Fdm1dMesher > * >(argp2)->get());
    }
  }
  {
    try {
      result = (Glued1dMesher *)new Glued1dMesher((Fdm1dMesher const &)*arg1,(Fdm1dMesher const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Glued1dMesher > *smartresult = result ? new ext::shared_ptr<  Glued1dMesher >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Glued1dMesher_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Glued1dMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Glued1dMesher *arg1 = (Glued1dMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Glued1dMesher > tempshared1 ;
  ext::shared_ptr< Glued1dMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Glued1dMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Glued1dMesher" "', argument " "1"" of type '" "Glued1dMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Glued1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Glued1dMesher > * >(argp1);
      arg1 = const_cast< Glued1dMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Glued1dMesher > * >(argp1);
      arg1 = const_cast< Glued1dMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Glued1dMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Glued1dMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Glued1dMesher_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmLinearOpIterator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FdmLinearOpIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLinearOpIterator" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmLinearOpIterator" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (FdmLinearOpIterator *)new_FdmLinearOpIterator__SWIG_0((std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmLinearOpIterator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  Size arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdmLinearOpIterator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLinearOpIterator" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmLinearOpIterator" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmLinearOpIterator" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmLinearOpIterator" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmLinearOpIterator" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdmLinearOpIterator *)new_FdmLinearOpIterator__SWIG_1((std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmLinearOpIterator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmLinearOpIterator", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdmLinearOpIterator__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmLinearOpIterator__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmLinearOpIterator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmLinearOpIterator::FdmLinearOpIterator(std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    FdmLinearOpIterator::FdmLinearOpIterator(std::vector< unsigned int,std::allocator< unsigned int > > const &,std::vector< unsigned int,std::allocator< unsigned int > > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpIterator_coordinates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmLinearOpIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpIterator_coordinates" "', argument " "1"" of type '" "FdmLinearOpIterator *""'"); 
  }
  arg1 = reinterpret_cast< FdmLinearOpIterator * >(argp1);
  {
    try {
      result = FdmLinearOpIterator_coordinates(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpIterator_increment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmLinearOpIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpIterator_increment" "', argument " "1"" of type '" "FdmLinearOpIterator *""'"); 
  }
  arg1 = reinterpret_cast< FdmLinearOpIterator * >(argp1);
  {
    try {
      FdmLinearOpIterator_increment(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpIterator_notEqual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpIterator_notEqual", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmLinearOpIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpIterator_notEqual" "', argument " "1"" of type '" "FdmLinearOpIterator *""'"); 
  }
  arg1 = reinterpret_cast< FdmLinearOpIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpIterator_notEqual" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpIterator_notEqual" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  {
    try {
      result = (bool)FdmLinearOpIterator_notEqual(arg1,(FdmLinearOpIterator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpIterator_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmLinearOpIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpIterator_index" "', argument " "1"" of type '" "FdmLinearOpIterator const *""'"); 
  }
  arg1 = reinterpret_cast< FdmLinearOpIterator * >(argp1);
  {
    try {
      result = ((FdmLinearOpIterator const *)arg1)->index();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOpIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpIterator *arg1 = (FdmLinearOpIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLinearOpIterator" "', argument " "1"" of type '" "FdmLinearOpIterator *""'"); 
  }
  arg1 = reinterpret_cast< FdmLinearOpIterator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLinearOpIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FdmLinearOpIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmLinearOpIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmLinearOpLayout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  FdmLinearOpLayout *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLinearOpLayout" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmLinearOpLayout" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (FdmLinearOpLayout *)new_FdmLinearOpLayout((std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLinearOpLayout > *smartresult = result ? new ext::shared_ptr<  FdmLinearOpLayout >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_spacing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_spacing" "', argument " "1"" of type '" "FdmLinearOpLayout *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = FdmLinearOpLayout_spacing(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_dim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_dim" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = FdmLinearOpLayout_dim((FdmLinearOpLayout const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_index(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Size result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpLayout_index", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_index" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpLayout_index" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpLayout_index" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = FdmLinearOpLayout_index((FdmLinearOpLayout const *)arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< FdmLinearOpIterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_begin" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmLinearOpIterator(result)), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< FdmLinearOpIterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_end" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmLinearOpIterator(result)), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_size" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_neighbourhood__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  Integer arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Size result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->neighbourhood((FdmLinearOpIterator const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_neighbourhood__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  Integer arg4 ;
  Size arg5 ;
  Integer arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Size result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FdmLinearOpLayout_neighbourhood" "', argument " "6"" of type '" "Integer""'");
  } 
  arg6 = static_cast< Integer >(val6);
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->neighbourhood((FdmLinearOpIterator const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_neighbourhood(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmLinearOpLayout_neighbourhood", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FdmLinearOpLayout_neighbourhood__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_FdmLinearOpLayout_neighbourhood__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmLinearOpLayout_neighbourhood'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmLinearOpLayout::neighbourhood(FdmLinearOpIterator const &,Size,Integer) const\n"
    "    FdmLinearOpLayout::neighbourhood(FdmLinearOpIterator const &,Size,Integer,Size,Integer) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpLayout_iter_neighbourhood(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  Integer arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  SwigValueWrapper< FdmLinearOpIterator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpLayout_iter_neighbourhood", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpLayout_iter_neighbourhood" "', argument " "1"" of type '" "FdmLinearOpLayout const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpLayout_iter_neighbourhood" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpLayout_iter_neighbourhood" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmLinearOpLayout_iter_neighbourhood" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmLinearOpLayout_iter_neighbourhood" "', argument " "4"" of type '" "Integer""'");
  } 
  arg4 = static_cast< Integer >(val4);
  {
    try {
      result = ((FdmLinearOpLayout const *)arg1)->iter_neighbourhood((FdmLinearOpIterator const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new FdmLinearOpIterator(result)), SWIGTYPE_p_FdmLinearOpIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOpLayout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpLayout *arg1 = (FdmLinearOpLayout *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout > tempshared1 ;
  ext::shared_ptr< FdmLinearOpLayout > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLinearOpLayout" "', argument " "1"" of type '" "FdmLinearOpLayout *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLinearOpLayout > * >(argp1);
      arg1 = const_cast< FdmLinearOpLayout * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLinearOpLayout_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmLinearOpLayout_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmMesher_dplus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher const > tempshared1 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmMesher_dplus", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesher_dplus" "', argument " "1"" of type '" "FdmMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmMesher_dplus" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmMesher_dplus" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmMesher_dplus" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((FdmMesher const *)arg1)->dplus((FdmLinearOpIterator const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmMesher_dminus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher const > tempshared1 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmMesher_dminus", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesher_dminus" "', argument " "1"" of type '" "FdmMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmMesher_dminus" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmMesher_dminus" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmMesher_dminus" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((FdmMesher const *)arg1)->dminus((FdmLinearOpIterator const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmMesher_location(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher const > tempshared1 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmMesher_location", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesher_location" "', argument " "1"" of type '" "FdmMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmMesher_location" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmMesher_location" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmMesher_location" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((FdmMesher const *)arg1)->location((FdmLinearOpIterator const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmMesher_locations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher const > tempshared1 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmMesher_locations", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesher_locations" "', argument " "1"" of type '" "FdmMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmMesher_locations" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = ((FdmMesher const *)arg1)->locations(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmMesher_layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher const > tempshared1 ;
  ext::shared_ptr< FdmMesher const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FdmLinearOpLayout > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesher_layout" "', argument " "1"" of type '" "FdmMesher const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FdmMesher const *)arg1)->layout();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLinearOpLayout > *smartresult = result ? new ext::shared_ptr<  FdmLinearOpLayout >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesher *arg1 = (FdmMesher *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  ext::shared_ptr< FdmMesher > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmMesher" "', argument " "1"" of type '" "FdmMesher *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmMesher > * >(argp1);
      arg1 = const_cast< FdmMesher * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmMesher_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FdmMesherComposite__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmLinearOpLayout > *arg1 = 0 ;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  FdmMesherComposite *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "ext::shared_ptr< FdmLinearOpLayout > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpLayout > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpLayout > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *ptr = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmMesherComposite" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmMesherComposite" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< FdmLinearOpLayout > const &)*arg1,(std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesherComposite > *smartresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmMesherComposite__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  FdmMesherComposite *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *ptr = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesherComposite > *smartresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmMesherComposite__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared1 ;
  FdmMesherComposite *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesherComposite > *smartresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmMesherComposite__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared2 ;
  FdmMesherComposite *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmMesherComposite" "', argument " "2"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesherComposite > *smartresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmMesherComposite__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared3 ;
  FdmMesherComposite *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmMesherComposite" "', argument " "2"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmMesherComposite" "', argument " "3"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2,(ext::shared_ptr< Fdm1dMesher > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesherComposite > *smartresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmMesherComposite__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Fdm1dMesher > *arg1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< Fdm1dMesher > tempshared4 ;
  FdmMesherComposite *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmMesherComposite" "', argument " "1"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmMesherComposite" "', argument " "2"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmMesherComposite" "', argument " "3"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmMesherComposite" "', argument " "4"" of type '" "ext::shared_ptr< Fdm1dMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< Fdm1dMesher > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (FdmMesherComposite *)new FdmMesherComposite((ext::shared_ptr< Fdm1dMesher > const &)*arg1,(ext::shared_ptr< Fdm1dMesher > const &)*arg2,(ext::shared_ptr< Fdm1dMesher > const &)*arg3,(ext::shared_ptr< Fdm1dMesher > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesherComposite > *smartresult = result ? new ext::shared_ptr<  FdmMesherComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmMesherComposite(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmMesherComposite", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdmMesherComposite__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdmMesherComposite__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmMesherComposite__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmMesherComposite__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdmMesherComposite__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FdmMesherComposite__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmMesherComposite'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmMesherComposite::FdmMesherComposite(ext::shared_ptr< FdmLinearOpLayout > const &,std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)\n"
    "    FdmMesherComposite::FdmMesherComposite(std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > const &)\n"
    "    FdmMesherComposite::FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const &)\n"
    "    FdmMesherComposite::FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const &,ext::shared_ptr< Fdm1dMesher > const &)\n"
    "    FdmMesherComposite::FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const &,ext::shared_ptr< Fdm1dMesher > const &,ext::shared_ptr< Fdm1dMesher > const &)\n"
    "    FdmMesherComposite::FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const &,ext::shared_ptr< Fdm1dMesher > const &,ext::shared_ptr< Fdm1dMesher > const &,ext::shared_ptr< Fdm1dMesher > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmMesherComposite_getFdm1dMeshers(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesherComposite const > tempshared1 ;
  ext::shared_ptr< FdmMesherComposite const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmMesherComposite_getFdm1dMeshers" "', argument " "1"" of type '" "FdmMesherComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmMesherComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmMesherComposite > * >(argp1);
      arg1 = const_cast< FdmMesherComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmMesherComposite > * >(argp1);
      arg1 = const_cast< FdmMesherComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > *) &((FdmMesherComposite const *)arg1)->getFdm1dMeshers();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< Fdm1dMesher >,std::allocator< ext::shared_ptr< Fdm1dMesher > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmMesherComposite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmMesherComposite *arg1 = (FdmMesherComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesherComposite > tempshared1 ;
  ext::shared_ptr< FdmMesherComposite > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmMesherComposite" "', argument " "1"" of type '" "FdmMesherComposite *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmMesherComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmMesherComposite > * >(argp1);
      arg1 = const_cast< FdmMesherComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmMesherComposite > * >(argp1);
      arg1 = const_cast< FdmMesherComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmMesherComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmMesherComposite_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmMesherComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmLinearOp_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOp *arg1 = (FdmLinearOp *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOp const > tempshared1 ;
  ext::shared_ptr< FdmLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOp_apply", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOp_apply" "', argument " "1"" of type '" "FdmLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOp > * >(argp1);
      arg1 = const_cast< FdmLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOp > * >(argp1);
      arg1 = const_cast< FdmLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOp_apply" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOp_apply" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((FdmLinearOp const *)arg1)->apply((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOp *arg1 = (FdmLinearOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOp > tempshared1 ;
  ext::shared_ptr< FdmLinearOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLinearOp" "', argument " "1"" of type '" "FdmLinearOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp1);
      arg1 = const_cast< FdmLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp1);
      arg1 = const_cast< FdmLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLinearOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLinearOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SparseMatrix_row_idx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = (std::vector< unsigned int,std::allocator< unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_row_idx_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_row_idx_set" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_row_idx_set" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp2);
  if (arg1) (arg1)->row_idx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SparseMatrix_row_idx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_row_idx_get" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (std::vector< unsigned int,std::allocator< unsigned int > > *)& ((arg1)->row_idx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SparseMatrix_col_idx_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = (std::vector< unsigned int,std::allocator< unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_col_idx_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_col_idx_set" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_col_idx_set" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp2);
  if (arg1) (arg1)->col_idx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SparseMatrix_col_idx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_col_idx_get" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (std::vector< unsigned int,std::allocator< unsigned int > > *)& ((arg1)->col_idx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SparseMatrix_data_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = (std::vector< Real,std::allocator< Real > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_data_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_data_set" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_data_set" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp2);
  if (arg1) (arg1)->data = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SparseMatrix_data_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_data_get" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (std::vector< Real,std::allocator< Real > > *)& ((arg1)->data);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SparseMatrix", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (SparseMatrix *)new SparseMatrix();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SparseMatrix > *smartresult = result ? new ext::shared_ptr<  SparseMatrix >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SparseMatrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SparseMatrix *arg1 = (SparseMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SparseMatrix > tempshared1 ;
  ext::shared_ptr< SparseMatrix > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SparseMatrix" "', argument " "1"" of type '" "SparseMatrix *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SparseMatrix > * >(argp1);
      arg1 = const_cast< SparseMatrix * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SparseMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SparseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_size" "', argument " "1"" of type '" "FdmLinearOpComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_setTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpComposite_setTime", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_setTime" "', argument " "1"" of type '" "FdmLinearOpComposite *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmLinearOpComposite_setTime" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmLinearOpComposite_setTime" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->setTime(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_apply_mixed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpComposite_apply_mixed", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_apply_mixed" "', argument " "1"" of type '" "FdmLinearOpComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpComposite_apply_mixed" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpComposite_apply_mixed" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->apply_mixed((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_apply_direction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpComposite_apply_direction", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_apply_direction" "', argument " "1"" of type '" "FdmLinearOpComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmLinearOpComposite_apply_direction" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmLinearOpComposite_apply_direction" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpComposite_apply_direction" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->apply_direction(arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_solve_splitting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Size arg2 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpComposite_solve_splitting", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_solve_splitting" "', argument " "1"" of type '" "FdmLinearOpComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmLinearOpComposite_solve_splitting" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmLinearOpComposite_solve_splitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpComposite_solve_splitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmLinearOpComposite_solve_splitting" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->solve_splitting(arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_preconditioner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmLinearOpComposite_preconditioner", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_preconditioner" "', argument " "1"" of type '" "FdmLinearOpComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmLinearOpComposite_preconditioner" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmLinearOpComposite_preconditioner" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmLinearOpComposite_preconditioner" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = ((FdmLinearOpComposite const *)arg1)->preconditioner((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmLinearOpComposite_to_sparse_matrix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite const > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< SparseMatrix > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmLinearOpComposite_to_sparse_matrix" "', argument " "1"" of type '" "FdmLinearOpComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = FdmLinearOpComposite_to_sparse_matrix((FdmLinearOpComposite const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SparseMatrix > *smartresult = result ? new ext::shared_ptr<  SparseMatrix >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SparseMatrix_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOpComposite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpComposite *arg1 = (FdmLinearOpComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared1 ;
  ext::shared_ptr< FdmLinearOpComposite > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLinearOpComposite" "', argument " "1"" of type '" "FdmLinearOpComposite *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLinearOpComposite > * >(argp1);
      arg1 = const_cast< FdmLinearOpComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLinearOpComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FdmLinearOpCompositeProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  FdmLinearOpCompositeProxy *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      result = (FdmLinearOpCompositeProxy *)new FdmLinearOpCompositeProxy(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLinearOpCompositeProxy > *smartresult = result ? new ext::shared_ptr<  FdmLinearOpCompositeProxy >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLinearOpCompositeProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLinearOpCompositeProxy *arg1 = (FdmLinearOpCompositeProxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpCompositeProxy > tempshared1 ;
  ext::shared_ptr< FdmLinearOpCompositeProxy > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLinearOpCompositeProxy" "', argument " "1"" of type '" "FdmLinearOpCompositeProxy *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOpCompositeProxy > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOpCompositeProxy > * >(argp1);
      arg1 = const_cast< FdmLinearOpCompositeProxy * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLinearOpCompositeProxy > * >(argp1);
      arg1 = const_cast< FdmLinearOpCompositeProxy * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLinearOpCompositeProxy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmLinearOpCompositeProxy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmBoundaryCondition_applyBeforeApplying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  FdmLinearOp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > tempshared1 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmLinearOp > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryCondition_applyBeforeApplying", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryCondition_applyBeforeApplying" "', argument " "1"" of type '" "FdmBoundaryCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOp_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryCondition_applyBeforeApplying" "', argument " "2"" of type '" "FdmLinearOp &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryCondition_applyBeforeApplying" "', argument " "2"" of type '" "FdmLinearOp &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp2);
      arg2 = const_cast< FdmLinearOp * >(tempshared2.get());
    } else {
      arg2 = const_cast< FdmLinearOp * >(reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp2)->get());
    }
  }
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyBeforeApplying(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryCondition_applyAfterApplying(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > tempshared1 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryCondition_applyAfterApplying", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryCondition_applyAfterApplying" "', argument " "1"" of type '" "FdmBoundaryCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryCondition_applyAfterApplying" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryCondition_applyAfterApplying" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyAfterApplying(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryCondition_applyBeforeSolving(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  FdmLinearOp *arg2 = 0 ;
  Array *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > tempshared1 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmLinearOp > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryCondition_applyBeforeSolving", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryCondition_applyBeforeSolving" "', argument " "1"" of type '" "FdmBoundaryCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOp_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryCondition_applyBeforeSolving" "', argument " "2"" of type '" "FdmLinearOp &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryCondition_applyBeforeSolving" "', argument " "2"" of type '" "FdmLinearOp &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp2);
      arg2 = const_cast< FdmLinearOp * >(tempshared2.get());
    } else {
      arg2 = const_cast< FdmLinearOp * >(reinterpret_cast< ext::shared_ptr<  FdmLinearOp > * >(argp2)->get());
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBoundaryCondition_applyBeforeSolving" "', argument " "3"" of type '" "Array &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryCondition_applyBeforeSolving" "', argument " "3"" of type '" "Array &""'"); 
  }
  arg3 = reinterpret_cast< Array * >(argp3);
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyBeforeSolving(*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryCondition_applyAfterSolving(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition const > tempshared1 ;
  ext::shared_ptr< FdmBoundaryCondition const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryCondition_applyAfterSolving", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryCondition_applyAfterSolving" "', argument " "1"" of type '" "FdmBoundaryCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryCondition_applyAfterSolving" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryCondition_applyAfterSolving" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  {
    try {
      ((FdmBoundaryCondition const *)arg1)->applyAfterSolving(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryCondition_setTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempshared1 ;
  ext::shared_ptr< FdmBoundaryCondition > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryCondition_setTime", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryCondition_setTime" "', argument " "1"" of type '" "FdmBoundaryCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryCondition_setTime" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setTime(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmBoundaryCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBoundaryCondition *arg1 = (FdmBoundaryCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBoundaryCondition > tempshared1 ;
  ext::shared_ptr< FdmBoundaryCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBoundaryCondition" "', argument " "1"" of type '" "FdmBoundaryCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBoundaryCondition > * >(argp1);
      arg1 = const_cast< FdmBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBoundaryCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____nonzero__((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____bool__((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____len__((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmBoundaryConditionSet___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryConditionSet___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FdmBoundaryConditionSet___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_FdmBoundaryConditionSet___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__setslice__(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__setslice__(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type,std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmBoundaryConditionSet___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_FdmBoundaryConditionSet___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmBoundaryConditionSet___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__delitem__(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBoundaryCondition > *smartresult = *result ? new ext::shared_ptr<  FdmBoundaryCondition >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_FdmBoundaryConditionSet___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmBoundaryConditionSet___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__getitem__(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBoundaryConditionSet___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< FdmBoundaryCondition > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_FdmBoundaryConditionSet___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmBoundaryConditionSet___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmBoundaryConditionSet___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::__setitem__(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBoundaryCondition > *smartresult = result ? new ext::shared_ptr<  FdmBoundaryCondition >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryConditionSet_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__append(arg1,(ext::shared_ptr< FdmBoundaryCondition > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBoundaryConditionSet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)new std::vector< ext::shared_ptr< FdmBoundaryCondition > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBoundaryConditionSet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBoundaryConditionSet" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBoundaryConditionSet" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)new std::vector< ext::shared_ptr< FdmBoundaryCondition > >((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryConditionSet_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBoundaryConditionSet_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< FdmBoundaryCondition > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBoundaryConditionSet__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmBoundaryConditionSet" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)new std::vector< ext::shared_ptr< FdmBoundaryCondition > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_FdmBoundaryConditionSet_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_FdmBoundaryConditionSet_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::erase(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::erase(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_FdmBoundaryConditionSet__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg1 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmBoundaryConditionSet" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBoundaryConditionSet" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *)new std::vector< ext::shared_ptr< FdmBoundaryCondition > >(arg1,(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBoundaryConditionSet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmBoundaryConditionSet", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FdmBoundaryConditionSet__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FdmBoundaryConditionSet__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdmBoundaryConditionSet__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmBoundaryConditionSet__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmBoundaryConditionSet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::vector()\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::vector(std::vector< ext::shared_ptr< FdmBoundaryCondition > > const &)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::vector(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::vector(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBoundaryConditionSet_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *) &((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBoundaryCondition > *smartresult = *result ? new ext::shared_ptr<  FdmBoundaryCondition >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *) &((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBoundaryCondition > *smartresult = *result ? new ext::shared_ptr<  FdmBoundaryCondition >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBoundaryConditionSet_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBoundaryConditionSet_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmBoundaryConditionSet_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmBoundaryConditionSet_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::resize(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::resize(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< FdmBoundaryCondition > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator arg2 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg3 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FdmBoundaryConditionSet_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_FdmBoundaryCondition_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< FdmBoundaryCondition > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmBoundaryConditionSet_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_FdmBoundaryCondition_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_FdmBoundaryConditionSet_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmBoundaryConditionSet_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::insert(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< FdmBoundaryCondition > >::insert(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type,std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBoundaryConditionSet_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmBoundaryConditionSet_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBoundaryConditionSet_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBoundaryConditionSet_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< FdmBoundaryCondition > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmBoundaryConditionSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< FdmBoundaryCondition > > *arg1 = (std::vector< ext::shared_ptr< FdmBoundaryCondition > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBoundaryConditionSet" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< FdmBoundaryCondition > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBoundaryConditionSet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_FdmBoundaryCondition_t_std__allocatorT_ext__shared_ptrT_FdmBoundaryCondition_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBoundaryConditionSet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmDirichletBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  FdmDirichletBoundary::Side arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  FdmDirichletBoundary *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmDirichletBoundary", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmDirichletBoundary" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmDirichletBoundary" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmDirichletBoundary" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmDirichletBoundary" "', argument " "4"" of type '" "FdmDirichletBoundary::Side""'");
  } 
  arg4 = static_cast< FdmDirichletBoundary::Side >(val4);
  {
    try {
      result = (FdmDirichletBoundary *)new FdmDirichletBoundary((ext::shared_ptr< FdmMesher > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmDirichletBoundary > *smartresult = result ? new ext::shared_ptr<  FdmDirichletBoundary >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmDirichletBoundary_applyAfterApplying__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FdmDirichletBoundary *arg1 = (FdmDirichletBoundary *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDirichletBoundary const > tempshared1 ;
  ext::shared_ptr< FdmDirichletBoundary const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmDirichletBoundary_applyAfterApplying" "', argument " "1"" of type '" "FdmDirichletBoundary const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmDirichletBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDirichletBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDirichletBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmDirichletBoundary_applyAfterApplying" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmDirichletBoundary_applyAfterApplying" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  {
    try {
      ((FdmDirichletBoundary const *)arg1)->applyAfterApplying(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmDirichletBoundary_applyAfterApplying__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FdmDirichletBoundary *arg1 = (FdmDirichletBoundary *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDirichletBoundary const > tempshared1 ;
  ext::shared_ptr< FdmDirichletBoundary const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmDirichletBoundary_applyAfterApplying" "', argument " "1"" of type '" "FdmDirichletBoundary const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmDirichletBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDirichletBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDirichletBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmDirichletBoundary_applyAfterApplying" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmDirichletBoundary_applyAfterApplying" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmDirichletBoundary const *)arg1)->applyAfterApplying(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmDirichletBoundary_applyAfterApplying(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmDirichletBoundary_applyAfterApplying", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FdmDirichletBoundary_applyAfterApplying__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FdmDirichletBoundary_applyAfterApplying__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmDirichletBoundary_applyAfterApplying'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmDirichletBoundary::applyAfterApplying(Array &) const\n"
    "    FdmDirichletBoundary::applyAfterApplying(Real,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmDirichletBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDirichletBoundary *arg1 = (FdmDirichletBoundary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDirichletBoundary > tempshared1 ;
  ext::shared_ptr< FdmDirichletBoundary > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmDirichletBoundary" "', argument " "1"" of type '" "FdmDirichletBoundary *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmDirichletBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDirichletBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDirichletBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmDirichletBoundary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmDirichletBoundary_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmDirichletBoundary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmDiscountDirichletBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Time arg3 ;
  Real arg4 ;
  Size arg5 ;
  FdmDiscountDirichletBoundary::Side arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  FdmDiscountDirichletBoundary *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmDiscountDirichletBoundary", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmDiscountDirichletBoundary" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmDiscountDirichletBoundary" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmDiscountDirichletBoundary" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmDiscountDirichletBoundary" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmDiscountDirichletBoundary" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmDiscountDirichletBoundary" "', argument " "6"" of type '" "FdmDiscountDirichletBoundary::Side""'");
  } 
  arg6 = static_cast< FdmDiscountDirichletBoundary::Side >(val6);
  {
    try {
      result = (FdmDiscountDirichletBoundary *)new FdmDiscountDirichletBoundary((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmDiscountDirichletBoundary > *smartresult = result ? new ext::shared_ptr<  FdmDiscountDirichletBoundary >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmDiscountDirichletBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDiscountDirichletBoundary *arg1 = (FdmDiscountDirichletBoundary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDiscountDirichletBoundary > tempshared1 ;
  ext::shared_ptr< FdmDiscountDirichletBoundary > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmDiscountDirichletBoundary" "', argument " "1"" of type '" "FdmDiscountDirichletBoundary *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmDiscountDirichletBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmDiscountDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDiscountDirichletBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmDiscountDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmDiscountDirichletBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmDiscountDirichletBoundary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmDiscountDirichletBoundary_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmDiscountDirichletBoundary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmTimeDepDirichletBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Size arg3 ;
  FdmTimeDepDirichletBoundary::Side arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  FdmTimeDepDirichletBoundary *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmTimeDepDirichletBoundary", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmTimeDepDirichletBoundary" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmTimeDepDirichletBoundary" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmTimeDepDirichletBoundary" "', argument " "4"" of type '" "FdmTimeDepDirichletBoundary::Side""'");
  } 
  arg4 = static_cast< FdmTimeDepDirichletBoundary::Side >(val4);
  {
    try {
      result = (FdmTimeDepDirichletBoundary *)new_FdmTimeDepDirichletBoundary((ext::shared_ptr< FdmMesher > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmTimeDepDirichletBoundary > *smartresult = result ? new ext::shared_ptr<  FdmTimeDepDirichletBoundary >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmTimeDepDirichletBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmTimeDepDirichletBoundary *arg1 = (FdmTimeDepDirichletBoundary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmTimeDepDirichletBoundary > tempshared1 ;
  ext::shared_ptr< FdmTimeDepDirichletBoundary > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmTimeDepDirichletBoundary" "', argument " "1"" of type '" "FdmTimeDepDirichletBoundary *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmTimeDepDirichletBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmTimeDepDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmTimeDepDirichletBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmTimeDepDirichletBoundary > * >(argp1);
      arg1 = const_cast< FdmTimeDepDirichletBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmTimeDepDirichletBoundary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmTimeDepDirichletBoundary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmBatesOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< BatesProcess > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  Size arg4 ;
  ext::shared_ptr< FdmQuantoHelper > *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< BatesProcess > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared5 ;
  FdmBatesOp *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBatesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBatesOp" "', argument " "2"" of type '" "ext::shared_ptr< BatesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmBatesOp" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBatesOp" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBatesOp" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmBatesOp" "', argument " "5"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (FdmBatesOp *)new FdmBatesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< BatesProcess > const &)*arg2,(FdmBoundaryConditionSet const &)*arg3,arg4,(ext::shared_ptr< FdmQuantoHelper > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBatesOp > *smartresult = result ? new ext::shared_ptr<  FdmBatesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBatesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBatesOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< BatesProcess > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< BatesProcess > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdmBatesOp *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBatesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBatesOp" "', argument " "2"" of type '" "ext::shared_ptr< BatesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< BatesProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmBatesOp" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBatesOp" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBatesOp" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdmBatesOp *)new FdmBatesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< BatesProcess > const &)*arg2,(FdmBoundaryConditionSet const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBatesOp > *smartresult = result ? new ext::shared_ptr<  FdmBatesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBatesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBatesOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmBatesOp", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmBatesOp__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BatesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdmBatesOp__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmBatesOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmBatesOp::FdmBatesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< BatesProcess > const &,FdmBoundaryConditionSet const &,Size,ext::shared_ptr< FdmQuantoHelper > const &)\n"
    "    FdmBatesOp::FdmBatesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< BatesProcess > const &,FdmBoundaryConditionSet const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmBatesOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBatesOp *arg1 = (FdmBatesOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBatesOp > tempshared1 ;
  ext::shared_ptr< FdmBatesOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBatesOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBatesOp" "', argument " "1"" of type '" "FdmBatesOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBatesOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBatesOp > * >(argp1);
      arg1 = const_cast< FdmBatesOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBatesOp > * >(argp1);
      arg1 = const_cast< FdmBatesOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBatesOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBatesOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBatesOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmBlackScholesOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  doubleOrNull arg5 ;
  Size arg6 ;
  ext::shared_ptr< FdmQuantoHelper > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared7 ;
  FdmBlackScholesOp *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    if (swig_obj[4] == Py_None)
    arg5 = Null<double>();
    else if (PyFloat_Check(swig_obj[4]))
    arg5 = PyFloat_AsDouble(swig_obj[4]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmBlackScholesOp" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdmBlackScholesOp" "', argument " "7"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6,(ext::shared_ptr< FdmQuantoHelper > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  doubleOrNull arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdmBlackScholesOp *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    if (swig_obj[4] == Py_None)
    arg5 = Null<double>();
    else if (PyFloat_Check(swig_obj[4]))
    arg5 = PyFloat_AsDouble(swig_obj[4]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmBlackScholesOp" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesOp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  doubleOrNull arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FdmBlackScholesOp *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    if (swig_obj[4] == Py_None)
    arg5 = Null<double>();
    else if (PyFloat_Check(swig_obj[4]))
    arg5 = PyFloat_AsDouble(swig_obj[4]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesOp__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FdmBlackScholesOp *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesOp__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  FdmBlackScholesOp *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (FdmBlackScholesOp *)new FdmBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmBlackScholesOp", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmBlackScholesOp__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmBlackScholesOp__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = (argv[4] == Py_None || PyFloat_Check(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_new_FdmBlackScholesOp__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = (argv[4] == Py_None || PyFloat_Check(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdmBlackScholesOp__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = (argv[4] == Py_None || PyFloat_Check(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdmBlackScholesOp__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmBlackScholesOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmBlackScholesOp::FdmBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool,doubleOrNull,Size,ext::shared_ptr< FdmQuantoHelper > const &)\n"
    "    FdmBlackScholesOp::FdmBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool,doubleOrNull,Size)\n"
    "    FdmBlackScholesOp::FdmBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool,doubleOrNull)\n"
    "    FdmBlackScholesOp::FdmBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool)\n"
    "    FdmBlackScholesOp::FdmBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmBlackScholesOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBlackScholesOp *arg1 = (FdmBlackScholesOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBlackScholesOp > tempshared1 ;
  ext::shared_ptr< FdmBlackScholesOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBlackScholesOp" "', argument " "1"" of type '" "FdmBlackScholesOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBlackScholesOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBlackScholesOp > * >(argp1);
      arg1 = const_cast< FdmBlackScholesOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBlackScholesOp > * >(argp1);
      arg1 = const_cast< FdmBlackScholesOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBlackScholesOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBlackScholesOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm2dBlackScholesOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Time arg5 ;
  bool arg6 ;
  doubleOrNull arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Fdm2dBlackScholesOp *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    if (swig_obj[6] == Py_None)
    arg7 = Null<double>();
    else if (PyFloat_Check(swig_obj[6]))
    arg7 = PyFloat_AsDouble(swig_obj[6]);
    else
    SWIG_exception(SWIG_TypeError,"double expected");
  }
  {
    try {
      result = (Fdm2dBlackScholesOp *)new Fdm2dBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm2dBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  Fdm2dBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm2dBlackScholesOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Time arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Fdm2dBlackScholesOp *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (Fdm2dBlackScholesOp *)new Fdm2dBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm2dBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  Fdm2dBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm2dBlackScholesOp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg3 = 0 ;
  Real arg4 ;
  Time arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Fdm2dBlackScholesOp *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "3"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Fdm2dBlackScholesOp" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  {
    try {
      result = (Fdm2dBlackScholesOp *)new Fdm2dBlackScholesOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm2dBlackScholesOp > *smartresult = result ? new ext::shared_ptr<  Fdm2dBlackScholesOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Fdm2dBlackScholesOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Fdm2dBlackScholesOp", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Fdm2dBlackScholesOp__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Fdm2dBlackScholesOp__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = (argv[6] == Py_None || PyFloat_Check(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_new_Fdm2dBlackScholesOp__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Fdm2dBlackScholesOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Fdm2dBlackScholesOp::Fdm2dBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Time,bool,doubleOrNull)\n"
    "    Fdm2dBlackScholesOp::Fdm2dBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Time,bool)\n"
    "    Fdm2dBlackScholesOp::Fdm2dBlackScholesOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,Time)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Fdm2dBlackScholesOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesOp *arg1 = (Fdm2dBlackScholesOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesOp > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm2dBlackScholesOp" "', argument " "1"" of type '" "Fdm2dBlackScholesOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm2dBlackScholesOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm2dBlackScholesOp > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm2dBlackScholesOp > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm2dBlackScholesOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm2dBlackScholesOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmCEVOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  FdmCEVOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmCEVOp", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmCEVOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmCEVOp" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmCEVOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmCEVOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmCEVOp" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmCEVOp" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdmCEVOp *)new FdmCEVOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmCEVOp > *smartresult = result ? new ext::shared_ptr<  FdmCEVOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmCEVOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmCEVOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmCEVOp *arg1 = (FdmCEVOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmCEVOp > tempshared1 ;
  ext::shared_ptr< FdmCEVOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmCEVOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmCEVOp" "', argument " "1"" of type '" "FdmCEVOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmCEVOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmCEVOp > * >(argp1);
      arg1 = const_cast< FdmCEVOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmCEVOp > * >(argp1);
      arg1 = const_cast< FdmCEVOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmCEVOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmCEVOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmCEVOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmG2Op(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< G2 > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< G2 > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  FdmG2Op *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmG2Op", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmG2Op" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmG2Op" "', argument " "2"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmG2Op" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmG2Op" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdmG2Op *)new FdmG2Op((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< G2 > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmG2Op > *smartresult = result ? new ext::shared_ptr<  FdmG2Op >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmG2Op_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmG2Op(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmG2Op *arg1 = (FdmG2Op *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmG2Op > tempshared1 ;
  ext::shared_ptr< FdmG2Op > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmG2Op_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmG2Op" "', argument " "1"" of type '" "FdmG2Op *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmG2Op > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmG2Op > * >(argp1);
      arg1 = const_cast< FdmG2Op * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmG2Op > * >(argp1);
      arg1 = const_cast< FdmG2Op * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmG2Op_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmG2Op_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmG2Op_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonHullWhiteOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< HullWhiteProcess > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< HullWhiteProcess > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  FdmHestonHullWhiteOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmHestonHullWhiteOp", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonHullWhiteOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonHullWhiteOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonHullWhiteOp" "', argument " "3"" of type '" "ext::shared_ptr< HullWhiteProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmHestonHullWhiteOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (FdmHestonHullWhiteOp *)new FdmHestonHullWhiteOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< HullWhiteProcess > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonHullWhiteOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonHullWhiteOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonHullWhiteOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonHullWhiteOp *arg1 = (FdmHestonHullWhiteOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonHullWhiteOp > tempshared1 ;
  ext::shared_ptr< FdmHestonHullWhiteOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonHullWhiteOp" "', argument " "1"" of type '" "FdmHestonHullWhiteOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonHullWhiteOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonHullWhiteOp > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonHullWhiteOp > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonHullWhiteOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonHullWhiteOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared4 ;
  FdmHestonOp *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonOp" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmHestonOp" "', argument " "4"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (FdmHestonOp *)new FdmHestonOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared3 ;
  FdmHestonOp *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonOp" "', argument " "3"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdmHestonOp *)new FdmHestonOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,(ext::shared_ptr< FdmQuantoHelper > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonOp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  FdmHestonOp *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdmHestonOp *)new FdmHestonOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmHestonOp", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmHestonOp__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdmHestonOp__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FdmHestonOp__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmHestonOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmHestonOp::FdmHestonOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdmHestonOp::FdmHestonOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< FdmQuantoHelper > const &)\n"
    "    FdmHestonOp::FdmHestonOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< HestonProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonOp *arg1 = (FdmHestonOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonOp > tempshared1 ;
  ext::shared_ptr< FdmHestonOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonOp" "', argument " "1"" of type '" "FdmHestonOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonOp > * >(argp1);
      arg1 = const_cast< FdmHestonOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonOp > * >(argp1);
      arg1 = const_cast< FdmHestonOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHullWhiteOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HullWhite > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  FdmHullWhiteOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmHullWhiteOp", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHullWhiteOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHullWhiteOp" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHullWhiteOp" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdmHullWhiteOp *)new FdmHullWhiteOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HullWhite > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHullWhiteOp > *smartresult = result ? new ext::shared_ptr<  FdmHullWhiteOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHullWhiteOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHullWhiteOp *arg1 = (FdmHullWhiteOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHullWhiteOp > tempshared1 ;
  ext::shared_ptr< FdmHullWhiteOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHullWhiteOp" "', argument " "1"" of type '" "FdmHullWhiteOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHullWhiteOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHullWhiteOp > * >(argp1);
      arg1 = const_cast< FdmHullWhiteOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHullWhiteOp > * >(argp1);
      arg1 = const_cast< FdmHullWhiteOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHullWhiteOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHullWhiteOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmLocalVolFwdOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Quote > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared5 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdmLocalVolFwdOp *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLocalVolFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmLocalVolFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmLocalVolFwdOp" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmLocalVolFwdOp" "', argument " "4"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmLocalVolFwdOp" "', argument " "5"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmLocalVolFwdOp" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdmLocalVolFwdOp *)new FdmLocalVolFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< Quote > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< YieldTermStructure > const &)*arg4,(ext::shared_ptr< LocalVolTermStructure > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLocalVolFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmLocalVolFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLocalVolFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmLocalVolFwdOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< Quote > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Quote > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared5 ;
  FdmLocalVolFwdOp *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLocalVolFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmLocalVolFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmLocalVolFwdOp" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmLocalVolFwdOp" "', argument " "4"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmLocalVolFwdOp" "', argument " "5"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (FdmLocalVolFwdOp *)new FdmLocalVolFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< Quote > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< YieldTermStructure > const &)*arg4,(ext::shared_ptr< LocalVolTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLocalVolFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmLocalVolFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLocalVolFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmLocalVolFwdOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmLocalVolFwdOp", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdmLocalVolFwdOp__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Quote_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdmLocalVolFwdOp__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmLocalVolFwdOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmLocalVolFwdOp::FdmLocalVolFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< Quote > const &,ext::shared_ptr< YieldTermStructure > const &,ext::shared_ptr< YieldTermStructure > const &,ext::shared_ptr< LocalVolTermStructure > const &,Size)\n"
    "    FdmLocalVolFwdOp::FdmLocalVolFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< Quote > const &,ext::shared_ptr< YieldTermStructure > const &,ext::shared_ptr< YieldTermStructure > const &,ext::shared_ptr< LocalVolTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmLocalVolFwdOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLocalVolFwdOp *arg1 = (FdmLocalVolFwdOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLocalVolFwdOp > tempshared1 ;
  ext::shared_ptr< FdmLocalVolFwdOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLocalVolFwdOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLocalVolFwdOp" "', argument " "1"" of type '" "FdmLocalVolFwdOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLocalVolFwdOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLocalVolFwdOp > * >(argp1);
      arg1 = const_cast< FdmLocalVolFwdOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLocalVolFwdOp > * >(argp1);
      arg1 = const_cast< FdmLocalVolFwdOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLocalVolFwdOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLocalVolFwdOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmLocalVolFwdOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmOrnsteinUhlenbeckOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdmOrnsteinUhlenbeckOp *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "2"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdmOrnsteinUhlenbeckOp *)new FdmOrnsteinUhlenbeckOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmOrnsteinUhlenbeckOp > *smartresult = result ? new ext::shared_ptr<  FdmOrnsteinUhlenbeckOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmOrnsteinUhlenbeckOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< OrnsteinUhlenbeckProcess > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  FdmOrnsteinUhlenbeckOp *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "2"" of type '" "ext::shared_ptr< OrnsteinUhlenbeckProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< OrnsteinUhlenbeckProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmOrnsteinUhlenbeckOp" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdmOrnsteinUhlenbeckOp *)new FdmOrnsteinUhlenbeckOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< OrnsteinUhlenbeckProcess > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmOrnsteinUhlenbeckOp > *smartresult = result ? new ext::shared_ptr<  FdmOrnsteinUhlenbeckOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmOrnsteinUhlenbeckOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmOrnsteinUhlenbeckOp", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdmOrnsteinUhlenbeckOp__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmOrnsteinUhlenbeckOp__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmOrnsteinUhlenbeckOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmOrnsteinUhlenbeckOp::FdmOrnsteinUhlenbeckOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size)\n"
    "    FdmOrnsteinUhlenbeckOp::FdmOrnsteinUhlenbeckOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< OrnsteinUhlenbeckProcess > const &,ext::shared_ptr< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmOrnsteinUhlenbeckOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmOrnsteinUhlenbeckOp *arg1 = (FdmOrnsteinUhlenbeckOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmOrnsteinUhlenbeckOp > tempshared1 ;
  ext::shared_ptr< FdmOrnsteinUhlenbeckOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmOrnsteinUhlenbeckOp" "', argument " "1"" of type '" "FdmOrnsteinUhlenbeckOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmOrnsteinUhlenbeckOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmOrnsteinUhlenbeckOp > * >(argp1);
      arg1 = const_cast< FdmOrnsteinUhlenbeckOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmOrnsteinUhlenbeckOp > * >(argp1);
      arg1 = const_cast< FdmOrnsteinUhlenbeckOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmOrnsteinUhlenbeckOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmOrnsteinUhlenbeckOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSabrOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  FdmSabrOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmSabrOp", 7, 7, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSabrOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSabrOp" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSabrOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSabrOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSabrOp" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmSabrOp" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdmSabrOp" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (FdmSabrOp *)new FdmSabrOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSabrOp > *smartresult = result ? new ext::shared_ptr<  FdmSabrOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSabrOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmSabrOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSabrOp *arg1 = (FdmSabrOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSabrOp > tempshared1 ;
  ext::shared_ptr< FdmSabrOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSabrOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSabrOp" "', argument " "1"" of type '" "FdmSabrOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmSabrOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmSabrOp > * >(argp1);
      arg1 = const_cast< FdmSabrOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmSabrOp > * >(argp1);
      arg1 = const_cast< FdmSabrOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSabrOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmSabrOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSabrOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmZabrOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  FdmZabrOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmZabrOp", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmZabrOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmZabrOp" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmZabrOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmZabrOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmZabrOp" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FdmZabrOp *)new FdmZabrOp((ext::shared_ptr< FdmMesher > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmZabrOp > *smartresult = result ? new ext::shared_ptr<  FdmZabrOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmZabrOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmZabrOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmZabrOp *arg1 = (FdmZabrOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmZabrOp > tempshared1 ;
  ext::shared_ptr< FdmZabrOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmZabrOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmZabrOp" "', argument " "1"" of type '" "FdmZabrOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmZabrOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmZabrOp > * >(argp1);
      arg1 = const_cast< FdmZabrOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmZabrOp > * >(argp1);
      arg1 = const_cast< FdmZabrOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmZabrOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmZabrOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmZabrOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmDupire1dOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Array *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  FdmDupire1dOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmDupire1dOp", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmDupire1dOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmDupire1dOp" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmDupire1dOp" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (FdmDupire1dOp *)new FdmDupire1dOp((ext::shared_ptr< FdmMesher > const &)*arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmDupire1dOp > *smartresult = result ? new ext::shared_ptr<  FdmDupire1dOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmDupire1dOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmDupire1dOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDupire1dOp *arg1 = (FdmDupire1dOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDupire1dOp > tempshared1 ;
  ext::shared_ptr< FdmDupire1dOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDupire1dOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmDupire1dOp" "', argument " "1"" of type '" "FdmDupire1dOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmDupire1dOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmDupire1dOp > * >(argp1);
      arg1 = const_cast< FdmDupire1dOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmDupire1dOp > * >(argp1);
      arg1 = const_cast< FdmDupire1dOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmDupire1dOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmDupire1dOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmDupire1dOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmBlackScholesFwdOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesFwdOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesFwdOp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesFwdOp__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  FdmBlackScholesFwdOp *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmBlackScholesFwdOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (FdmBlackScholesFwdOp *)new FdmBlackScholesFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBlackScholesFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmBlackScholesFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmBlackScholesFwdOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmBlackScholesFwdOp", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmBlackScholesFwdOp__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmBlackScholesFwdOp__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdmBlackScholesFwdOp__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdmBlackScholesFwdOp__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmBlackScholesFwdOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmBlackScholesFwdOp::FdmBlackScholesFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool,Real,Size)\n"
    "    FdmBlackScholesFwdOp::FdmBlackScholesFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool,Real)\n"
    "    FdmBlackScholesFwdOp::FdmBlackScholesFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real,bool)\n"
    "    FdmBlackScholesFwdOp::FdmBlackScholesFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmBlackScholesFwdOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBlackScholesFwdOp *arg1 = (FdmBlackScholesFwdOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBlackScholesFwdOp > tempshared1 ;
  ext::shared_ptr< FdmBlackScholesFwdOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBlackScholesFwdOp" "', argument " "1"" of type '" "FdmBlackScholesFwdOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBlackScholesFwdOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBlackScholesFwdOp > * >(argp1);
      arg1 = const_cast< FdmBlackScholesFwdOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBlackScholesFwdOp > * >(argp1);
      arg1 = const_cast< FdmBlackScholesFwdOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBlackScholesFwdOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBlackScholesFwdOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBlackScholesFwdOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSquareRootFwdOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Size arg5 ;
  FdmSquareRootFwdOp::TransformationType arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FdmSquareRootFwdOp *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSquareRootFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmSquareRootFwdOp" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSquareRootFwdOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSquareRootFwdOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSquareRootFwdOp" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmSquareRootFwdOp" "', argument " "6"" of type '" "FdmSquareRootFwdOp::TransformationType""'");
  } 
  arg6 = static_cast< FdmSquareRootFwdOp::TransformationType >(val6);
  {
    try {
      result = (FdmSquareRootFwdOp *)new FdmSquareRootFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSquareRootFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmSquareRootFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSquareRootFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSquareRootFwdOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdmSquareRootFwdOp *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSquareRootFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmSquareRootFwdOp" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmSquareRootFwdOp" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSquareRootFwdOp" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSquareRootFwdOp" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdmSquareRootFwdOp *)new FdmSquareRootFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSquareRootFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmSquareRootFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSquareRootFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSquareRootFwdOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmSquareRootFwdOp", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdmSquareRootFwdOp__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FdmSquareRootFwdOp__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmSquareRootFwdOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmSquareRootFwdOp::FdmSquareRootFwdOp(ext::shared_ptr< FdmMesher > const &,Real,Real,Real,Size,FdmSquareRootFwdOp::TransformationType)\n"
    "    FdmSquareRootFwdOp::FdmSquareRootFwdOp(ext::shared_ptr< FdmMesher > const &,Real,Real,Real,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmSquareRootFwdOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSquareRootFwdOp *arg1 = (FdmSquareRootFwdOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSquareRootFwdOp > tempshared1 ;
  ext::shared_ptr< FdmSquareRootFwdOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSquareRootFwdOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSquareRootFwdOp" "', argument " "1"" of type '" "FdmSquareRootFwdOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmSquareRootFwdOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmSquareRootFwdOp > * >(argp1);
      arg1 = const_cast< FdmSquareRootFwdOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmSquareRootFwdOp > * >(argp1);
      arg1 = const_cast< FdmSquareRootFwdOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSquareRootFwdOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmSquareRootFwdOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSquareRootFwdOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonFwdOp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  FdmSquareRootFwdOp::TransformationType arg3 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared4 ;
  FdmHestonFwdOp *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonFwdOp" "', argument " "3"" of type '" "FdmSquareRootFwdOp::TransformationType""'");
  } 
  arg3 = static_cast< FdmSquareRootFwdOp::TransformationType >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmHestonFwdOp" "', argument " "4"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (FdmHestonFwdOp *)new FdmHestonFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,arg3,(ext::shared_ptr< LocalVolTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonFwdOp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  FdmSquareRootFwdOp::TransformationType arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  FdmHestonFwdOp *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonFwdOp" "', argument " "3"" of type '" "FdmSquareRootFwdOp::TransformationType""'");
  } 
  arg3 = static_cast< FdmSquareRootFwdOp::TransformationType >(val3);
  {
    try {
      result = (FdmHestonFwdOp *)new FdmHestonFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonFwdOp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< HestonProcess > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared2 ;
  FdmHestonFwdOp *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonFwdOp" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonFwdOp" "', argument " "2"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdmHestonFwdOp *)new FdmHestonFwdOp((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< HestonProcess > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonFwdOp > *smartresult = result ? new ext::shared_ptr<  FdmHestonFwdOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonFwdOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonFwdOp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmHestonFwdOp", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmHestonFwdOp__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmHestonFwdOp__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FdmHestonFwdOp__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmHestonFwdOp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmHestonFwdOp::FdmHestonFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< HestonProcess > const &,FdmSquareRootFwdOp::TransformationType,ext::shared_ptr< LocalVolTermStructure > const &)\n"
    "    FdmHestonFwdOp::FdmHestonFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< HestonProcess > const &,FdmSquareRootFwdOp::TransformationType)\n"
    "    FdmHestonFwdOp::FdmHestonFwdOp(ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< HestonProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonFwdOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonFwdOp *arg1 = (FdmHestonFwdOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonFwdOp > tempshared1 ;
  ext::shared_ptr< FdmHestonFwdOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonFwdOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonFwdOp" "', argument " "1"" of type '" "FdmHestonFwdOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonFwdOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonFwdOp > * >(argp1);
      arg1 = const_cast< FdmHestonFwdOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonFwdOp > * >(argp1);
      arg1 = const_cast< FdmHestonFwdOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonFwdOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonFwdOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonFwdOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TripleBandLinearOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  PyObject *swig_obj[2] ;
  TripleBandLinearOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TripleBandLinearOp", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TripleBandLinearOp" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleBandLinearOp" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (TripleBandLinearOp *)new TripleBandLinearOp(arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TripleBandLinearOp > *smartresult = result ? new ext::shared_ptr<  TripleBandLinearOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_apply", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_apply" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_apply" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_apply" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->apply((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_solve_splitting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Array result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->solve_splitting((Array const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_solve_splitting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Array result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TripleBandLinearOp_solve_splitting" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->solve_splitting((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_solve_splitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_solve_splitting", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TripleBandLinearOp_solve_splitting__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TripleBandLinearOp_solve_splitting__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TripleBandLinearOp_solve_splitting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TripleBandLinearOp::solve_splitting(Array const &,Real,Real) const\n"
    "    TripleBandLinearOp::solve_splitting(Array const &,Real) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_mult(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_mult", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_mult" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_mult" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_mult" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->mult((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TripleBandLinearOp > *smartresult = new ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result));
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_multR(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_multR", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_multR" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_multR" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_multR" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->multR((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TripleBandLinearOp > *smartresult = new ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result));
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  TripleBandLinearOp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared2 ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_add" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_add" "', argument " "2"" of type '" "TripleBandLinearOp const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_add" "', argument " "2"" of type '" "TripleBandLinearOp const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp2);
      arg2 = const_cast< TripleBandLinearOp * >(tempshared2.get());
    } else {
      arg2 = const_cast< TripleBandLinearOp * >(reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp2)->get());
    }
  }
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->add((TripleBandLinearOp const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TripleBandLinearOp > *smartresult = new ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result));
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp const > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< TripleBandLinearOp > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_add" "', argument " "1"" of type '" "TripleBandLinearOp const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((TripleBandLinearOp const *)arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  TripleBandLinearOp > *smartresult = new ext::shared_ptr<  TripleBandLinearOp >(new TripleBandLinearOp(result));
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_add", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TripleBandLinearOp_add__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_TripleBandLinearOp_add__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TripleBandLinearOp_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TripleBandLinearOp::add(TripleBandLinearOp const &) const\n"
    "    TripleBandLinearOp::add(Array const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_axpyb(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  Array *arg2 = 0 ;
  TripleBandLinearOp *arg3 = 0 ;
  TripleBandLinearOp *arg4 = 0 ;
  Array *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< TripleBandLinearOp const > tempshared4 ;
  Array temp5 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_axpyb", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_axpyb" "', argument " "1"" of type '" "TripleBandLinearOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_axpyb" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_axpyb" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleBandLinearOp_axpyb" "', argument " "3"" of type '" "TripleBandLinearOp const &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_axpyb" "', argument " "3"" of type '" "TripleBandLinearOp const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp3);
      arg3 = const_cast< TripleBandLinearOp * >(tempshared3.get());
    } else {
      arg3 = const_cast< TripleBandLinearOp * >(reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TripleBandLinearOp_axpyb" "', argument " "4"" of type '" "TripleBandLinearOp const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_axpyb" "', argument " "4"" of type '" "TripleBandLinearOp const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp4);
      arg4 = const_cast< TripleBandLinearOp * >(tempshared4.get());
    } else {
      arg4 = const_cast< TripleBandLinearOp * >(reinterpret_cast< ext::shared_ptr< const TripleBandLinearOp > * >(argp4)->get());
    }
  }
  {
    if (ArrayFromSequence(swig_obj[4],&temp5)) {
      arg5 = &temp5;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TripleBandLinearOp_axpyb" "', argument " "5"" of type '" "Array const &""'");
      }
      if (!argp5) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_axpyb" "', argument " "5"" of type '" "Array const &""'"); 
      }
      arg5 = reinterpret_cast< Array * >(argp5);
    }
  }
  {
    try {
      (arg1)->axpyb((Array const &)*arg2,(TripleBandLinearOp const &)*arg3,(TripleBandLinearOp const &)*arg4,(Array const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TripleBandLinearOp_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  TripleBandLinearOp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< TripleBandLinearOp > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TripleBandLinearOp_swap", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleBandLinearOp_swap" "', argument " "1"" of type '" "TripleBandLinearOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleBandLinearOp_swap" "', argument " "2"" of type '" "TripleBandLinearOp &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleBandLinearOp_swap" "', argument " "2"" of type '" "TripleBandLinearOp &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp2);
      arg2 = const_cast< TripleBandLinearOp * >(tempshared2.get());
    } else {
      arg2 = const_cast< TripleBandLinearOp * >(reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp2)->get());
    }
  }
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TripleBandLinearOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TripleBandLinearOp *arg1 = (TripleBandLinearOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< TripleBandLinearOp > tempshared1 ;
  ext::shared_ptr< TripleBandLinearOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleBandLinearOp" "', argument " "1"" of type '" "TripleBandLinearOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  TripleBandLinearOp > * >(argp1);
      arg1 = const_cast< TripleBandLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TripleBandLinearOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_TripleBandLinearOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TripleBandLinearOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FirstDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  PyObject *swig_obj[2] ;
  FirstDerivativeOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FirstDerivativeOp", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FirstDerivativeOp" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FirstDerivativeOp" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FirstDerivativeOp *)new FirstDerivativeOp(arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FirstDerivativeOp > *smartresult = result ? new ext::shared_ptr<  FirstDerivativeOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FirstDerivativeOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FirstDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FirstDerivativeOp *arg1 = (FirstDerivativeOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FirstDerivativeOp > tempshared1 ;
  ext::shared_ptr< FirstDerivativeOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FirstDerivativeOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FirstDerivativeOp" "', argument " "1"" of type '" "FirstDerivativeOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FirstDerivativeOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FirstDerivativeOp > * >(argp1);
      arg1 = const_cast< FirstDerivativeOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FirstDerivativeOp > * >(argp1);
      arg1 = const_cast< FirstDerivativeOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FirstDerivativeOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FirstDerivativeOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FirstDerivativeOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SecondDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  PyObject *swig_obj[2] ;
  SecondDerivativeOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SecondDerivativeOp", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SecondDerivativeOp" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SecondDerivativeOp" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (SecondDerivativeOp *)new SecondDerivativeOp(arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SecondDerivativeOp > *smartresult = result ? new ext::shared_ptr<  SecondDerivativeOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SecondDerivativeOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SecondDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SecondDerivativeOp *arg1 = (SecondDerivativeOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SecondDerivativeOp > tempshared1 ;
  ext::shared_ptr< SecondDerivativeOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SecondDerivativeOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondDerivativeOp" "', argument " "1"" of type '" "SecondDerivativeOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SecondDerivativeOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SecondDerivativeOp > * >(argp1);
      arg1 = const_cast< SecondDerivativeOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SecondDerivativeOp > * >(argp1);
      arg1 = const_cast< SecondDerivativeOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecondDerivativeOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SecondDerivativeOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SecondDerivativeOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NinePointLinearOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  ext::shared_ptr< FdmMesher > *arg3 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared3 ;
  PyObject *swig_obj[3] ;
  NinePointLinearOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NinePointLinearOp", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NinePointLinearOp" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NinePointLinearOp" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NinePointLinearOp" "', argument " "3"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (NinePointLinearOp *)new NinePointLinearOp(arg1,arg2,(ext::shared_ptr< FdmMesher > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NinePointLinearOp > *smartresult = result ? new ext::shared_ptr<  NinePointLinearOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NinePointLinearOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NinePointLinearOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NinePointLinearOp *arg1 = (NinePointLinearOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NinePointLinearOp > tempshared1 ;
  ext::shared_ptr< NinePointLinearOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NinePointLinearOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NinePointLinearOp" "', argument " "1"" of type '" "NinePointLinearOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NinePointLinearOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NinePointLinearOp > * >(argp1);
      arg1 = const_cast< NinePointLinearOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NinePointLinearOp > * >(argp1);
      arg1 = const_cast< NinePointLinearOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NinePointLinearOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NinePointLinearOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NinePointLinearOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SecondOrderMixedDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  ext::shared_ptr< FdmMesher > *arg3 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared3 ;
  PyObject *swig_obj[3] ;
  SecondOrderMixedDerivativeOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SecondOrderMixedDerivativeOp", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SecondOrderMixedDerivativeOp" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderMixedDerivativeOp" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SecondOrderMixedDerivativeOp" "', argument " "3"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (SecondOrderMixedDerivativeOp *)new SecondOrderMixedDerivativeOp(arg1,arg2,(ext::shared_ptr< FdmMesher > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SecondOrderMixedDerivativeOp > *smartresult = result ? new ext::shared_ptr<  SecondOrderMixedDerivativeOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SecondOrderMixedDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SecondOrderMixedDerivativeOp *arg1 = (SecondOrderMixedDerivativeOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SecondOrderMixedDerivativeOp > tempshared1 ;
  ext::shared_ptr< SecondOrderMixedDerivativeOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondOrderMixedDerivativeOp" "', argument " "1"" of type '" "SecondOrderMixedDerivativeOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SecondOrderMixedDerivativeOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SecondOrderMixedDerivativeOp > * >(argp1);
      arg1 = const_cast< SecondOrderMixedDerivativeOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SecondOrderMixedDerivativeOp > * >(argp1);
      arg1 = const_cast< SecondOrderMixedDerivativeOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecondOrderMixedDerivativeOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SecondOrderMixedDerivativeOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NthOrderDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Integer arg3 ;
  ext::shared_ptr< FdmMesher > *arg4 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared4 ;
  PyObject *swig_obj[4] ;
  NthOrderDerivativeOp *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NthOrderDerivativeOp", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NthOrderDerivativeOp" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NthOrderDerivativeOp" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NthOrderDerivativeOp" "', argument " "3"" of type '" "Integer""'");
  } 
  arg3 = static_cast< Integer >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NthOrderDerivativeOp" "', argument " "4"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      result = (NthOrderDerivativeOp *)new NthOrderDerivativeOp(arg1,arg2,arg3,(ext::shared_ptr< FdmMesher > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NthOrderDerivativeOp > *smartresult = result ? new ext::shared_ptr<  NthOrderDerivativeOp >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NthOrderDerivativeOp_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NthOrderDerivativeOp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NthOrderDerivativeOp *arg1 = (NthOrderDerivativeOp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NthOrderDerivativeOp > tempshared1 ;
  ext::shared_ptr< NthOrderDerivativeOp > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NthOrderDerivativeOp_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NthOrderDerivativeOp" "', argument " "1"" of type '" "NthOrderDerivativeOp *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NthOrderDerivativeOp > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NthOrderDerivativeOp > * >(argp1);
      arg1 = const_cast< NthOrderDerivativeOp * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NthOrderDerivativeOp > * >(argp1);
      arg1 = const_cast< NthOrderDerivativeOp * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NthOrderDerivativeOp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NthOrderDerivativeOp_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NthOrderDerivativeOp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CraigSneydScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  CraigSneydScheme *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CraigSneydScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CraigSneydScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CraigSneydScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CraigSneydScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CraigSneydScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (CraigSneydScheme *)new CraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CraigSneydScheme > *smartresult = result ? new ext::shared_ptr<  CraigSneydScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CraigSneydScheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  CraigSneydScheme *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CraigSneydScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CraigSneydScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CraigSneydScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (CraigSneydScheme *)new CraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CraigSneydScheme > *smartresult = result ? new ext::shared_ptr<  CraigSneydScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CraigSneydScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CraigSneydScheme", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_CraigSneydScheme__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_CraigSneydScheme__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CraigSneydScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CraigSneydScheme::CraigSneydScheme(Real,Real,ext::shared_ptr< FdmLinearOpComposite > const &,FdmBoundaryConditionSet const &)\n"
    "    CraigSneydScheme::CraigSneydScheme(Real,Real,ext::shared_ptr< FdmLinearOpComposite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CraigSneydScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CraigSneydScheme *arg1 = (CraigSneydScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CraigSneydScheme > tempshared1 ;
  ext::shared_ptr< CraigSneydScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CraigSneydScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CraigSneydScheme_step" "', argument " "1"" of type '" "CraigSneydScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      arg1 = const_cast< CraigSneydScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      arg1 = const_cast< CraigSneydScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CraigSneydScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CraigSneydScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CraigSneydScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CraigSneydScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CraigSneydScheme *arg1 = (CraigSneydScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CraigSneydScheme > tempshared1 ;
  ext::shared_ptr< CraigSneydScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CraigSneydScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CraigSneydScheme_setStep" "', argument " "1"" of type '" "CraigSneydScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      arg1 = const_cast< CraigSneydScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      arg1 = const_cast< CraigSneydScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CraigSneydScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CraigSneydScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CraigSneydScheme *arg1 = (CraigSneydScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CraigSneydScheme > tempshared1 ;
  ext::shared_ptr< CraigSneydScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CraigSneydScheme" "', argument " "1"" of type '" "CraigSneydScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      arg1 = const_cast< CraigSneydScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CraigSneydScheme > * >(argp1);
      arg1 = const_cast< CraigSneydScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CraigSneydScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CraigSneydScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CraigSneydScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ImplicitEulerScheme(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet const &arg2_defvalue = FdmBoundaryConditionSet() ;
  FdmBoundaryConditionSet *arg2 = (FdmBoundaryConditionSet *) &arg2_defvalue ;
  Real arg3 = (Real) 1e-8 ;
  ImplicitEulerScheme::SolverType arg4 = (ImplicitEulerScheme::SolverType) ImplicitEulerScheme::BiCGstab ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"map",  (char *)"bcSet",  (char *)"relTol",  (char *)"solverType",  NULL 
  };
  ImplicitEulerScheme *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:new_ImplicitEulerScheme", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImplicitEulerScheme" "', argument " "1"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1) : &tempshared1;
    }
  }
  if (obj1) {
    {
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
      res2 = swig::asptr(obj1, &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ImplicitEulerScheme" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImplicitEulerScheme" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
      }
      arg2 = ptr;
    }
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_double(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImplicitEulerScheme" "', argument " "3"" of type '" "Real""'");
    } 
    arg3 = static_cast< Real >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ImplicitEulerScheme" "', argument " "4"" of type '" "ImplicitEulerScheme::SolverType""'");
    } 
    arg4 = static_cast< ImplicitEulerScheme::SolverType >(val4);
  }
  {
    try {
      result = (ImplicitEulerScheme *)new ImplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ImplicitEulerScheme > *smartresult = result ? new ext::shared_ptr<  ImplicitEulerScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImplicitEulerScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ImplicitEulerScheme > tempshared1 ;
  ext::shared_ptr< ImplicitEulerScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImplicitEulerScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitEulerScheme_step" "', argument " "1"" of type '" "ImplicitEulerScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitEulerScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitEulerScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImplicitEulerScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImplicitEulerScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ImplicitEulerScheme > tempshared1 ;
  ext::shared_ptr< ImplicitEulerScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ImplicitEulerScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitEulerScheme_setStep" "', argument " "1"" of type '" "ImplicitEulerScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImplicitEulerScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImplicitEulerScheme_numberOfIterations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ImplicitEulerScheme const > tempshared1 ;
  ext::shared_ptr< ImplicitEulerScheme const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitEulerScheme_numberOfIterations" "', argument " "1"" of type '" "ImplicitEulerScheme const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ImplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ImplicitEulerScheme const *)arg1)->numberOfIterations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ImplicitEulerScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ImplicitEulerScheme *arg1 = (ImplicitEulerScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ImplicitEulerScheme > tempshared1 ;
  ext::shared_ptr< ImplicitEulerScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImplicitEulerScheme" "', argument " "1"" of type '" "ImplicitEulerScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ImplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ImplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ImplicitEulerScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ImplicitEulerScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ImplicitEulerScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CrankNicolsonScheme(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  FdmBoundaryConditionSet const &arg3_defvalue = FdmBoundaryConditionSet() ;
  FdmBoundaryConditionSet *arg3 = (FdmBoundaryConditionSet *) &arg3_defvalue ;
  Real arg4 = (Real) 1e-8 ;
  ImplicitEulerScheme::SolverType arg5 = (ImplicitEulerScheme::SolverType) ImplicitEulerScheme::BiCGstab ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"theta",  (char *)"map",  (char *)"bcSet",  (char *)"relTol",  (char *)"solverType",  NULL 
  };
  CrankNicolsonScheme *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:new_CrankNicolsonScheme", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CrankNicolsonScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CrankNicolsonScheme" "', argument " "2"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2) : &tempshared2;
    }
  }
  if (obj2) {
    {
      std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
      res3 = swig::asptr(obj2, &ptr);
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CrankNicolsonScheme" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CrankNicolsonScheme" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
      }
      arg3 = ptr;
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_double(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CrankNicolsonScheme" "', argument " "4"" of type '" "Real""'");
    } 
    arg4 = static_cast< Real >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CrankNicolsonScheme" "', argument " "5"" of type '" "ImplicitEulerScheme::SolverType""'");
    } 
    arg5 = static_cast< ImplicitEulerScheme::SolverType >(val5);
  }
  {
    try {
      result = (CrankNicolsonScheme *)new CrankNicolsonScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2,(FdmBoundaryConditionSet const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CrankNicolsonScheme > *smartresult = result ? new ext::shared_ptr<  CrankNicolsonScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrankNicolsonScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CrankNicolsonScheme > tempshared1 ;
  ext::shared_ptr< CrankNicolsonScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CrankNicolsonScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrankNicolsonScheme_step" "', argument " "1"" of type '" "CrankNicolsonScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrankNicolsonScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrankNicolsonScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CrankNicolsonScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrankNicolsonScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CrankNicolsonScheme > tempshared1 ;
  ext::shared_ptr< CrankNicolsonScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "CrankNicolsonScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrankNicolsonScheme_setStep" "', argument " "1"" of type '" "CrankNicolsonScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrankNicolsonScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CrankNicolsonScheme_numberOfIterations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CrankNicolsonScheme const > tempshared1 ;
  ext::shared_ptr< CrankNicolsonScheme const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrankNicolsonScheme_numberOfIterations" "', argument " "1"" of type '" "CrankNicolsonScheme const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CrankNicolsonScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CrankNicolsonScheme const *)arg1)->numberOfIterations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CrankNicolsonScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CrankNicolsonScheme *arg1 = (CrankNicolsonScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CrankNicolsonScheme > tempshared1 ;
  ext::shared_ptr< CrankNicolsonScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CrankNicolsonScheme" "', argument " "1"" of type '" "CrankNicolsonScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CrankNicolsonScheme > * >(argp1);
      arg1 = const_cast< CrankNicolsonScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CrankNicolsonScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CrankNicolsonScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CrankNicolsonScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DouglasScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  FdmBoundaryConditionSet *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  DouglasScheme *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DouglasScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DouglasScheme" "', argument " "2"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2) : &tempshared2;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DouglasScheme" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DouglasScheme" "', argument " "3"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (DouglasScheme *)new DouglasScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2,(FdmBoundaryConditionSet const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DouglasScheme > *smartresult = result ? new ext::shared_ptr<  DouglasScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DouglasScheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared2 ;
  DouglasScheme *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DouglasScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DouglasScheme" "', argument " "2"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (DouglasScheme *)new DouglasScheme(arg1,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DouglasScheme > *smartresult = result ? new ext::shared_ptr<  DouglasScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DouglasScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DouglasScheme", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DouglasScheme__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_DouglasScheme__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DouglasScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    DouglasScheme::DouglasScheme(Real,ext::shared_ptr< FdmLinearOpComposite > const &,FdmBoundaryConditionSet const &)\n"
    "    DouglasScheme::DouglasScheme(Real,ext::shared_ptr< FdmLinearOpComposite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DouglasScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DouglasScheme *arg1 = (DouglasScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DouglasScheme > tempshared1 ;
  ext::shared_ptr< DouglasScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DouglasScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DouglasScheme_step" "', argument " "1"" of type '" "DouglasScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      arg1 = const_cast< DouglasScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      arg1 = const_cast< DouglasScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DouglasScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DouglasScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DouglasScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DouglasScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DouglasScheme *arg1 = (DouglasScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DouglasScheme > tempshared1 ;
  ext::shared_ptr< DouglasScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "DouglasScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DouglasScheme_setStep" "', argument " "1"" of type '" "DouglasScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      arg1 = const_cast< DouglasScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      arg1 = const_cast< DouglasScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DouglasScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DouglasScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DouglasScheme *arg1 = (DouglasScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DouglasScheme > tempshared1 ;
  ext::shared_ptr< DouglasScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DouglasScheme" "', argument " "1"" of type '" "DouglasScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      arg1 = const_cast< DouglasScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DouglasScheme > * >(argp1);
      arg1 = const_cast< DouglasScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DouglasScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DouglasScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DouglasScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExplicitEulerScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  ExplicitEulerScheme *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExplicitEulerScheme" "', argument " "1"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExplicitEulerScheme" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExplicitEulerScheme" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (ExplicitEulerScheme *)new ExplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExplicitEulerScheme > *smartresult = result ? new ext::shared_ptr<  ExplicitEulerScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExplicitEulerScheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared1 ;
  ExplicitEulerScheme *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExplicitEulerScheme" "', argument " "1"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (ExplicitEulerScheme *)new ExplicitEulerScheme((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExplicitEulerScheme > *smartresult = result ? new ext::shared_ptr<  ExplicitEulerScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExplicitEulerScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExplicitEulerScheme", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExplicitEulerScheme__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ExplicitEulerScheme__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExplicitEulerScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExplicitEulerScheme::ExplicitEulerScheme(ext::shared_ptr< FdmLinearOpComposite > const &,FdmBoundaryConditionSet const &)\n"
    "    ExplicitEulerScheme::ExplicitEulerScheme(ext::shared_ptr< FdmLinearOpComposite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ExplicitEulerScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExplicitEulerScheme *arg1 = (ExplicitEulerScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExplicitEulerScheme > tempshared1 ;
  ext::shared_ptr< ExplicitEulerScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ExplicitEulerScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExplicitEulerScheme_step" "', argument " "1"" of type '" "ExplicitEulerScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ExplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ExplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExplicitEulerScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExplicitEulerScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExplicitEulerScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExplicitEulerScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExplicitEulerScheme *arg1 = (ExplicitEulerScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExplicitEulerScheme > tempshared1 ;
  ext::shared_ptr< ExplicitEulerScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ExplicitEulerScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExplicitEulerScheme_setStep" "', argument " "1"" of type '" "ExplicitEulerScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ExplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ExplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExplicitEulerScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExplicitEulerScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExplicitEulerScheme *arg1 = (ExplicitEulerScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExplicitEulerScheme > tempshared1 ;
  ext::shared_ptr< ExplicitEulerScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExplicitEulerScheme" "', argument " "1"" of type '" "ExplicitEulerScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ExplicitEulerScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExplicitEulerScheme > * >(argp1);
      arg1 = const_cast< ExplicitEulerScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExplicitEulerScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExplicitEulerScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExplicitEulerScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HundsdorferScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  HundsdorferScheme *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HundsdorferScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HundsdorferScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HundsdorferScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HundsdorferScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HundsdorferScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (HundsdorferScheme *)new HundsdorferScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HundsdorferScheme > *smartresult = result ? new ext::shared_ptr<  HundsdorferScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HundsdorferScheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  HundsdorferScheme *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HundsdorferScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HundsdorferScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HundsdorferScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (HundsdorferScheme *)new HundsdorferScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HundsdorferScheme > *smartresult = result ? new ext::shared_ptr<  HundsdorferScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HundsdorferScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HundsdorferScheme", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_HundsdorferScheme__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_HundsdorferScheme__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HundsdorferScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HundsdorferScheme::HundsdorferScheme(Real,Real,ext::shared_ptr< FdmLinearOpComposite > const &,FdmBoundaryConditionSet const &)\n"
    "    HundsdorferScheme::HundsdorferScheme(Real,Real,ext::shared_ptr< FdmLinearOpComposite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HundsdorferScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HundsdorferScheme *arg1 = (HundsdorferScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HundsdorferScheme > tempshared1 ;
  ext::shared_ptr< HundsdorferScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "HundsdorferScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HundsdorferScheme_step" "', argument " "1"" of type '" "HundsdorferScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      arg1 = const_cast< HundsdorferScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      arg1 = const_cast< HundsdorferScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HundsdorferScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HundsdorferScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HundsdorferScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HundsdorferScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HundsdorferScheme *arg1 = (HundsdorferScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HundsdorferScheme > tempshared1 ;
  ext::shared_ptr< HundsdorferScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "HundsdorferScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HundsdorferScheme_setStep" "', argument " "1"" of type '" "HundsdorferScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      arg1 = const_cast< HundsdorferScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      arg1 = const_cast< HundsdorferScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HundsdorferScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HundsdorferScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HundsdorferScheme *arg1 = (HundsdorferScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HundsdorferScheme > tempshared1 ;
  ext::shared_ptr< HundsdorferScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HundsdorferScheme" "', argument " "1"" of type '" "HundsdorferScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      arg1 = const_cast< HundsdorferScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HundsdorferScheme > * >(argp1);
      arg1 = const_cast< HundsdorferScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HundsdorferScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HundsdorferScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HundsdorferScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MethodOfLinesScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  MethodOfLinesScheme *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MethodOfLinesScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MethodOfLinesScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MethodOfLinesScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MethodOfLinesScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MethodOfLinesScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (MethodOfLinesScheme *)new MethodOfLinesScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MethodOfLinesScheme > *smartresult = result ? new ext::shared_ptr<  MethodOfLinesScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MethodOfLinesScheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  MethodOfLinesScheme *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MethodOfLinesScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MethodOfLinesScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MethodOfLinesScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (MethodOfLinesScheme *)new MethodOfLinesScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MethodOfLinesScheme > *smartresult = result ? new ext::shared_ptr<  MethodOfLinesScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MethodOfLinesScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MethodOfLinesScheme", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MethodOfLinesScheme__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MethodOfLinesScheme__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MethodOfLinesScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MethodOfLinesScheme::MethodOfLinesScheme(Real const,Real const,ext::shared_ptr< FdmLinearOpComposite > const &,FdmBoundaryConditionSet const &)\n"
    "    MethodOfLinesScheme::MethodOfLinesScheme(Real const,Real const,ext::shared_ptr< FdmLinearOpComposite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MethodOfLinesScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MethodOfLinesScheme *arg1 = (MethodOfLinesScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MethodOfLinesScheme > tempshared1 ;
  ext::shared_ptr< MethodOfLinesScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MethodOfLinesScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MethodOfLinesScheme_step" "', argument " "1"" of type '" "MethodOfLinesScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      arg1 = const_cast< MethodOfLinesScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      arg1 = const_cast< MethodOfLinesScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MethodOfLinesScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MethodOfLinesScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MethodOfLinesScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MethodOfLinesScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MethodOfLinesScheme *arg1 = (MethodOfLinesScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MethodOfLinesScheme > tempshared1 ;
  ext::shared_ptr< MethodOfLinesScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MethodOfLinesScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MethodOfLinesScheme_setStep" "', argument " "1"" of type '" "MethodOfLinesScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      arg1 = const_cast< MethodOfLinesScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      arg1 = const_cast< MethodOfLinesScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MethodOfLinesScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MethodOfLinesScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MethodOfLinesScheme *arg1 = (MethodOfLinesScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MethodOfLinesScheme > tempshared1 ;
  ext::shared_ptr< MethodOfLinesScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MethodOfLinesScheme" "', argument " "1"" of type '" "MethodOfLinesScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      arg1 = const_cast< MethodOfLinesScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MethodOfLinesScheme > * >(argp1);
      arg1 = const_cast< MethodOfLinesScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MethodOfLinesScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MethodOfLinesScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MethodOfLinesScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ModifiedCraigSneydScheme__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  FdmBoundaryConditionSet *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  ModifiedCraigSneydScheme *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModifiedCraigSneydScheme" "', argument " "4"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (ModifiedCraigSneydScheme *)new ModifiedCraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3,(FdmBoundaryConditionSet const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ModifiedCraigSneydScheme > *smartresult = result ? new ext::shared_ptr<  ModifiedCraigSneydScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModifiedCraigSneydScheme__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  ModifiedCraigSneydScheme *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ModifiedCraigSneydScheme" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (ModifiedCraigSneydScheme *)new ModifiedCraigSneydScheme(arg1,arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ModifiedCraigSneydScheme > *smartresult = result ? new ext::shared_ptr<  ModifiedCraigSneydScheme >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModifiedCraigSneydScheme(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ModifiedCraigSneydScheme", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ModifiedCraigSneydScheme__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ModifiedCraigSneydScheme__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ModifiedCraigSneydScheme'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ModifiedCraigSneydScheme::ModifiedCraigSneydScheme(Real,Real,ext::shared_ptr< FdmLinearOpComposite > const &,FdmBoundaryConditionSet const &)\n"
    "    ModifiedCraigSneydScheme::ModifiedCraigSneydScheme(Real,Real,ext::shared_ptr< FdmLinearOpComposite > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ModifiedCraigSneydScheme_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModifiedCraigSneydScheme *arg1 = (ModifiedCraigSneydScheme *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > tempshared1 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModifiedCraigSneydScheme_step", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModifiedCraigSneydScheme_step" "', argument " "1"" of type '" "ModifiedCraigSneydScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      arg1 = const_cast< ModifiedCraigSneydScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      arg1 = const_cast< ModifiedCraigSneydScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModifiedCraigSneydScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModifiedCraigSneydScheme_step" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ModifiedCraigSneydScheme_step" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      (arg1)->step(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ModifiedCraigSneydScheme_setStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModifiedCraigSneydScheme *arg1 = (ModifiedCraigSneydScheme *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > tempshared1 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ModifiedCraigSneydScheme_setStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModifiedCraigSneydScheme_setStep" "', argument " "1"" of type '" "ModifiedCraigSneydScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      arg1 = const_cast< ModifiedCraigSneydScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      arg1 = const_cast< ModifiedCraigSneydScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModifiedCraigSneydScheme_setStep" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      (arg1)->setStep(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ModifiedCraigSneydScheme(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ModifiedCraigSneydScheme *arg1 = (ModifiedCraigSneydScheme *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > tempshared1 ;
  ext::shared_ptr< ModifiedCraigSneydScheme > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModifiedCraigSneydScheme" "', argument " "1"" of type '" "ModifiedCraigSneydScheme *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      arg1 = const_cast< ModifiedCraigSneydScheme * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ModifiedCraigSneydScheme > * >(argp1);
      arg1 = const_cast< ModifiedCraigSneydScheme * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModifiedCraigSneydScheme_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ModifiedCraigSneydScheme_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ModifiedCraigSneydScheme_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmStepCondition_applyTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StepCondition< Array > *arg1 = (StepCondition< Array > *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StepCondition< Array > const > tempshared1 ;
  ext::shared_ptr< StepCondition< Array > const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepCondition_applyTo", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepCondition_applyTo" "', argument " "1"" of type '" "StepCondition< Array > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const StepCondition<Array> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const StepCondition<Array> > * >(argp1);
      arg1 = const_cast< StepCondition< Array > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const StepCondition<Array> > * >(argp1);
      arg1 = const_cast< StepCondition< Array > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmStepCondition_applyTo" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepCondition_applyTo" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmStepCondition_applyTo" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      ((StepCondition< Array > const *)arg1)->applyTo(*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmStepCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StepCondition< Array > *arg1 = (StepCondition< Array > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StepCondition< Array > > tempshared1 ;
  ext::shared_ptr< StepCondition< Array > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmStepCondition" "', argument " "1"" of type '" "StepCondition< Array > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StepCondition<Array> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StepCondition<Array> > * >(argp1);
      arg1 = const_cast< StepCondition< Array > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StepCondition<Array> > * >(argp1);
      arg1 = const_cast< StepCondition< Array > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmStepCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FdmStepConditionProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  FdmStepConditionProxy *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      result = (FdmStepConditionProxy *)new FdmStepConditionProxy(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmStepConditionProxy > *smartresult = result ? new ext::shared_ptr<  FdmStepConditionProxy >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionProxy_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmStepConditionProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmStepConditionProxy *arg1 = (FdmStepConditionProxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmStepConditionProxy > tempshared1 ;
  ext::shared_ptr< FdmStepConditionProxy > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionProxy_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmStepConditionProxy" "', argument " "1"" of type '" "FdmStepConditionProxy *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmStepConditionProxy > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmStepConditionProxy > * >(argp1);
      arg1 = const_cast< FdmStepConditionProxy * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmStepConditionProxy > * >(argp1);
      arg1 = const_cast< FdmStepConditionProxy * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmStepConditionProxy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionProxy_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmStepConditionProxy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmInnerValueCalculator_innerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmInnerValueCalculator *arg1 = (FdmInnerValueCalculator *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared1 ;
  ext::shared_ptr< FdmInnerValueCalculator > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmInnerValueCalculator_innerValue", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmInnerValueCalculator_innerValue" "', argument " "1"" of type '" "FdmInnerValueCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmInnerValueCalculator_innerValue" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmInnerValueCalculator_innerValue" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmInnerValueCalculator_innerValue" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(arg1)->innerValue((FdmLinearOpIterator const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmInnerValueCalculator_avgInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmInnerValueCalculator *arg1 = (FdmInnerValueCalculator *) 0 ;
  FdmLinearOpIterator *arg2 = 0 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared1 ;
  ext::shared_ptr< FdmInnerValueCalculator > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmInnerValueCalculator_avgInnerValue", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmInnerValueCalculator_avgInnerValue" "', argument " "1"" of type '" "FdmInnerValueCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmLinearOpIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmInnerValueCalculator_avgInnerValue" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmInnerValueCalculator_avgInnerValue" "', argument " "2"" of type '" "FdmLinearOpIterator const &""'"); 
  }
  arg2 = reinterpret_cast< FdmLinearOpIterator * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmInnerValueCalculator_avgInnerValue" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(arg1)->avgInnerValue((FdmLinearOpIterator const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmInnerValueCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmInnerValueCalculator *arg1 = (FdmInnerValueCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared1 ;
  ext::shared_ptr< FdmInnerValueCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmInnerValueCalculator" "', argument " "1"" of type '" "FdmInnerValueCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculator > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmInnerValueCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FdmInnerValueCalculatorProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject *swig_obj[1] ;
  FdmInnerValueCalculatorProxy *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  arg1 = swig_obj[0];
  {
    try {
      result = (FdmInnerValueCalculatorProxy *)new FdmInnerValueCalculatorProxy(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmInnerValueCalculatorProxy > *smartresult = result ? new ext::shared_ptr<  FdmInnerValueCalculatorProxy >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmInnerValueCalculatorProxy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmInnerValueCalculatorProxy *arg1 = (FdmInnerValueCalculatorProxy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculatorProxy > tempshared1 ;
  ext::shared_ptr< FdmInnerValueCalculatorProxy > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmInnerValueCalculatorProxy" "', argument " "1"" of type '" "FdmInnerValueCalculatorProxy *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculatorProxy > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculatorProxy > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculatorProxy * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmInnerValueCalculatorProxy > * >(argp1);
      arg1 = const_cast< FdmInnerValueCalculatorProxy * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmInnerValueCalculatorProxy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmInnerValueCalculatorProxy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmCellAveragingInnerValue__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Size arg3 ;
  PyObject *arg4 = (PyObject *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdmCellAveragingInnerValue *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmCellAveragingInnerValue" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmCellAveragingInnerValue" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmCellAveragingInnerValue" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  arg4 = swig_obj[3];
  {
    try {
      result = (FdmCellAveragingInnerValue *)new_FdmCellAveragingInnerValue__SWIG_0((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmCellAveragingInnerValue > *smartresult = result ? new ext::shared_ptr<  FdmCellAveragingInnerValue >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmCellAveragingInnerValue__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdmCellAveragingInnerValue *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmCellAveragingInnerValue" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmCellAveragingInnerValue" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmCellAveragingInnerValue" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdmCellAveragingInnerValue *)new_FdmCellAveragingInnerValue__SWIG_1((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmCellAveragingInnerValue > *smartresult = result ? new ext::shared_ptr<  FdmCellAveragingInnerValue >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmCellAveragingInnerValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmCellAveragingInnerValue", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Payoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdmCellAveragingInnerValue__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Payoff_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_new_FdmCellAveragingInnerValue__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmCellAveragingInnerValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmCellAveragingInnerValue::FdmCellAveragingInnerValue(ext::shared_ptr< Payoff > const &,ext::shared_ptr< FdmMesher > const &,Size,PyObject *)\n"
    "    FdmCellAveragingInnerValue::FdmCellAveragingInnerValue(ext::shared_ptr< Payoff > const &,ext::shared_ptr< FdmMesher > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmCellAveragingInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmCellAveragingInnerValue *arg1 = (FdmCellAveragingInnerValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmCellAveragingInnerValue > tempshared1 ;
  ext::shared_ptr< FdmCellAveragingInnerValue > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmCellAveragingInnerValue" "', argument " "1"" of type '" "FdmCellAveragingInnerValue *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmCellAveragingInnerValue > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmCellAveragingInnerValue > * >(argp1);
      arg1 = const_cast< FdmCellAveragingInnerValue * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmCellAveragingInnerValue > * >(argp1);
      arg1 = const_cast< FdmCellAveragingInnerValue * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmCellAveragingInnerValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmCellAveragingInnerValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmLogInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  FdmLogInnerValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmLogInnerValue", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLogInnerValue" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmLogInnerValue" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmLogInnerValue" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdmLogInnerValue *)new FdmLogInnerValue((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLogInnerValue > *smartresult = result ? new ext::shared_ptr<  FdmLogInnerValue >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLogInnerValue_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLogInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLogInnerValue *arg1 = (FdmLogInnerValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLogInnerValue > tempshared1 ;
  ext::shared_ptr< FdmLogInnerValue > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLogInnerValue_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLogInnerValue" "', argument " "1"" of type '" "FdmLogInnerValue *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLogInnerValue > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLogInnerValue > * >(argp1);
      arg1 = const_cast< FdmLogInnerValue * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLogInnerValue > * >(argp1);
      arg1 = const_cast< FdmLogInnerValue * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLogInnerValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLogInnerValue_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmLogInnerValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmLogBasketInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BasketPayoff > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BasketPayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  PyObject *swig_obj[2] ;
  FdmLogBasketInnerValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmLogBasketInnerValue", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BasketPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmLogBasketInnerValue" "', argument " "1"" of type '" "ext::shared_ptr< BasketPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BasketPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BasketPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BasketPayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmLogBasketInnerValue" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdmLogBasketInnerValue *)new FdmLogBasketInnerValue((ext::shared_ptr< BasketPayoff > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmLogBasketInnerValue > *smartresult = result ? new ext::shared_ptr<  FdmLogBasketInnerValue >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmLogBasketInnerValue_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmLogBasketInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmLogBasketInnerValue *arg1 = (FdmLogBasketInnerValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLogBasketInnerValue > tempshared1 ;
  ext::shared_ptr< FdmLogBasketInnerValue > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLogBasketInnerValue_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmLogBasketInnerValue" "', argument " "1"" of type '" "FdmLogBasketInnerValue *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmLogBasketInnerValue > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmLogBasketInnerValue > * >(argp1);
      arg1 = const_cast< FdmLogBasketInnerValue * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmLogBasketInnerValue > * >(argp1);
      arg1 = const_cast< FdmLogBasketInnerValue * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmLogBasketInnerValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmLogBasketInnerValue_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmLogBasketInnerValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmZeroInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmZeroInnerValue *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmZeroInnerValue", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (FdmZeroInnerValue *)new FdmZeroInnerValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmZeroInnerValue > *smartresult = result ? new ext::shared_ptr<  FdmZeroInnerValue >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmZeroInnerValue_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmZeroInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmZeroInnerValue *arg1 = (FdmZeroInnerValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmZeroInnerValue > tempshared1 ;
  ext::shared_ptr< FdmZeroInnerValue > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmZeroInnerValue_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmZeroInnerValue" "', argument " "1"" of type '" "FdmZeroInnerValue *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmZeroInnerValue > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmZeroInnerValue > * >(argp1);
      arg1 = const_cast< FdmZeroInnerValue * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmZeroInnerValue > * >(argp1);
      arg1 = const_cast< FdmZeroInnerValue * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmZeroInnerValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmZeroInnerValue_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmZeroInnerValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TimeToDateMap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< Time,Date > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeToDateMap" "', argument " "1"" of type '" "std::less< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeToDateMap" "', argument " "1"" of type '" "std::less< double > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< double > * >(argp1);
  {
    try {
      result = (std::map< Time,Date > *)new std::map< Time,Date >((std::less< double > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_iterator" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_Time_Sc_Date_Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___nonzero__" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_Time_Sc_Date_Sg____nonzero__((std::map< double,Date > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___bool__" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_Time_Sc_Date_Sg____bool__((std::map< double,Date > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< double,Date >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___len__" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = std_map_Sl_Time_Sc_Date_Sg____len__((std::map< double,Date > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< double,Date >::mapped_type *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___getitem__" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap___getitem__" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      try {
        result = (std::map< double,Date >::mapped_type *) &std_map_Sl_Time_Sc_Date_Sg____getitem__(arg1,(double const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Date, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___delitem__" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap___delitem__" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      try {
        std_map_Sl_Time_Sc_Date_Sg____delitem__(arg1,(double const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_has_key" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap_has_key" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (bool)std_map_Sl_Time_Sc_Date_Sg__has_key((std::map< double,Date > const *)arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_keys" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_Time_Sc_Date_Sg__keys(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_values" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_Time_Sc_Date_Sg__values(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_items" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_Time_Sc_Date_Sg__items(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___contains__" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap___contains__" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (bool)std_map_Sl_Time_Sc_Date_Sg____contains__(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_key_iterator" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_Time_Sc_Date_Sg__key_iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_value_iterator" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_Time_Sc_Date_Sg__value_iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___setitem__" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap___setitem__" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_map_Sl_Time_Sc_Date_Sg____setitem____SWIG_0(arg1,(double const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  std::map< double,Date >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap___setitem__" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap___setitem__" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeToDateMap___setitem__" "', argument " "3"" of type '" "std::map< double,Date >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeToDateMap___setitem__" "', argument " "3"" of type '" "std::map< double,Date >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< double,Date >::mapped_type * >(argp3);
  {
    try {
      try {
        std_map_Sl_Time_Sc_Date_Sg____setitem____SWIG_1(arg1,(double const &)*arg2,(Date const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TimeToDateMap___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TimeToDateMap___setitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TimeToDateMap___setitem____SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TimeToDateMap___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< Time,Date >::__setitem__(std::map< double,Date >::key_type const &)\n"
    "    std::map< Time,Date >::__setitem__(std::map< double,Date >::key_type const &,std::map< double,Date >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_asdict" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_Time_Sc_Date_Sg__asdict(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToDateMap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< Time,Date > *)new std::map< Time,Date >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToDateMap__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< Time,Date > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *ptr = (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeToDateMap" "', argument " "1"" of type '" "std::map< Time,Date > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeToDateMap" "', argument " "1"" of type '" "std::map< Time,Date > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< Time,Date > *)new std::map< Time,Date >((std::map< Time,Date > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToDateMap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TimeToDateMap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TimeToDateMap__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_double_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeToDateMap__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeToDateMap__SWIG_2(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TimeToDateMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< Time,Date >::map(std::less< double > const &)\n"
    "    std::map< Time,Date >::map()\n"
    "    std::map< Time,Date >::map(std::map< Time,Date > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_empty" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (bool)((std::map< Time,Date > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< double,Date >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_size" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = ((std::map< Time,Date > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< Time,Date > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_swap" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeToDateMap_swap" "', argument " "2"" of type '" "std::map< Time,Date > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeToDateMap_swap" "', argument " "2"" of type '" "std::map< Time,Date > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< Time,Date > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< double,Date >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_begin" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< double,Date >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_end" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< double,Date >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_rbegin" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::map< double,Date >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_rend" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_clear" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< double const,Date > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_get_allocator" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      result = ((std::map< Time,Date > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< double,Date >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_double_const_Date_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  std::map< double,Date >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_erase" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap_erase" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (arg1)->erase((std::map< double,Date >::key_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< double,Date >::size_type result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_count" "', argument " "1"" of type '" "std::map< Time,Date > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap_count" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = ((std::map< Time,Date > const *)arg1)->count((std::map< double,Date >::key_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  SwigValueWrapper< std::map< double,Date >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_erase" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "TimeToDateMap_erase" "', argument " "2"" of type '" "std::map< double,Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< double,Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< double,Date >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "TimeToDateMap_erase" "', argument " "2"" of type '" "std::map< double,Date >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_Time_Sc_Date_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  SwigValueWrapper< std::map< double,Date >::iterator > arg2 ;
  SwigValueWrapper< std::map< double,Date >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_erase" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "TimeToDateMap_erase" "', argument " "2"" of type '" "std::map< double,Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< double,Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< double,Date >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "TimeToDateMap_erase" "', argument " "2"" of type '" "std::map< double,Date >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "TimeToDateMap_erase" "', argument " "3"" of type '" "std::map< double,Date >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< double,Date >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< double,Date >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "TimeToDateMap_erase" "', argument " "3"" of type '" "std::map< double,Date >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_Time_Sc_Date_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "TimeToDateMap_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< double,Date >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_TimeToDateMap_erase__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TimeToDateMap_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< double,Date >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< double,Date >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_TimeToDateMap_erase__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TimeToDateMap_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< Time,Date >::erase(std::map< double,Date >::key_type const &)\n"
    "    std::map< Time,Date >::erase(std::map< double,Date >::iterator)\n"
    "    std::map< Time,Date >::erase(std::map< double,Date >::iterator,std::map< double,Date >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< double,Date >::iterator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_find" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap_find" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (arg1)->find((std::map< double,Date >::key_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< double,Date >::iterator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_lower_bound" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap_lower_bound" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (arg1)->lower_bound((std::map< double,Date >::key_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeToDateMap_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  std::map< double,Date >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,Date >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::map< double,Date >::iterator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TimeToDateMap_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeToDateMap_upper_bound" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeToDateMap_upper_bound" "', argument " "2"" of type '" "std::map< double,Date >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,Date >::key_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (arg1)->upper_bound((std::map< double,Date >::key_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,Date >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TimeToDateMap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< Time,Date > *arg1 = (std::map< Time,Date > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeToDateMap" "', argument " "1"" of type '" "std::map< Time,Date > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< Time,Date > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeToDateMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_double_Date_std__lessT_double_t_std__allocatorT_std__pairT_double_const_Date_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TimeToDateMap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmAffineG2ModelSwapInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  ext::shared_ptr< G2 > *arg2 = 0 ;
  ext::shared_ptr< VanillaSwap > *arg3 = 0 ;
  std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< G2 > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared5 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  FdmAffineModelSwapInnerValue< G2 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmAffineG2ModelSwapInnerValue", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "2"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "3"" of type '" "ext::shared_ptr< VanillaSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp3) : &tempshared3;
    }
  }
  {
    std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *ptr = (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "4"" of type '" "std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "4"" of type '" "std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "5"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmAffineG2ModelSwapInnerValue" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdmAffineModelSwapInnerValue< G2 > *)new FdmAffineModelSwapInnerValue< G2 >((ext::shared_ptr< G2 > const &)*arg1,(ext::shared_ptr< G2 > const &)*arg2,(ext::shared_ptr< VanillaSwap > const &)*arg3,(std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > const &)*arg4,(ext::shared_ptr< FdmMesher > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> > *smartresult = result ? new ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmAffineG2ModelSwapInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmAffineModelSwapInnerValue< G2 > *arg1 = (FdmAffineModelSwapInnerValue< G2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmAffineModelSwapInnerValue< G2 > > tempshared1 ;
  ext::shared_ptr< FdmAffineModelSwapInnerValue< G2 > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmAffineG2ModelSwapInnerValue" "', argument " "1"" of type '" "FdmAffineModelSwapInnerValue< G2 > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> > * >(argp1);
      arg1 = const_cast< FdmAffineModelSwapInnerValue< G2 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmAffineModelSwapInnerValue<G2> > * >(argp1);
      arg1 = const_cast< FdmAffineModelSwapInnerValue< G2 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmAffineG2ModelSwapInnerValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmAffineG2ModelSwapInnerValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmAffineHullWhiteModelSwapInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  ext::shared_ptr< HullWhite > *arg2 = 0 ;
  ext::shared_ptr< VanillaSwap > *arg3 = 0 ;
  std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > *arg4 = 0 ;
  ext::shared_ptr< FdmMesher > *arg5 = 0 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HullWhite > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared3 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared5 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  FdmAffineModelSwapInnerValue< HullWhite > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmAffineHullWhiteModelSwapInnerValue", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "2"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "3"" of type '" "ext::shared_ptr< VanillaSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp3) : &tempshared3;
    }
  }
  {
    std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *ptr = (std::map< double,Date,std::less< double >,std::allocator< std::pair< double const,Date > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "4"" of type '" "std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "4"" of type '" "std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "5"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp5) : &tempshared5;
    }
  }
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FdmAffineModelSwapInnerValue< HullWhite > *)new FdmAffineModelSwapInnerValue< HullWhite >((ext::shared_ptr< HullWhite > const &)*arg1,(ext::shared_ptr< HullWhite > const &)*arg2,(ext::shared_ptr< VanillaSwap > const &)*arg3,(std::map< Time,Date,std::less< Time >,std::allocator< std::pair< Time const,Date > > > const &)*arg4,(ext::shared_ptr< FdmMesher > const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> > *smartresult = result ? new ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmAffineHullWhiteModelSwapInnerValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmAffineModelSwapInnerValue< HullWhite > *arg1 = (FdmAffineModelSwapInnerValue< HullWhite > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmAffineModelSwapInnerValue< HullWhite > > tempshared1 ;
  ext::shared_ptr< FdmAffineModelSwapInnerValue< HullWhite > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmAffineHullWhiteModelSwapInnerValue" "', argument " "1"" of type '" "FdmAffineModelSwapInnerValue< HullWhite > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> > * >(argp1);
      arg1 = const_cast< FdmAffineModelSwapInnerValue< HullWhite > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmAffineModelSwapInnerValue<HullWhite> > * >(argp1);
      arg1 = const_cast< FdmAffineModelSwapInnerValue< HullWhite > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmAffineHullWhiteModelSwapInnerValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmAffineHullWhiteModelSwapInnerValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSnapshotCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Time arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  FdmSnapshotCondition *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmSnapshotCondition" "', argument " "1"" of type '" "Time""'");
  } 
  arg1 = static_cast< Time >(val1);
  {
    try {
      result = (FdmSnapshotCondition *)new FdmSnapshotCondition(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSnapshotCondition > *smartresult = result ? new ext::shared_ptr<  FdmSnapshotCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSnapshotCondition_getTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSnapshotCondition *arg1 = (FdmSnapshotCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSnapshotCondition const > tempshared1 ;
  ext::shared_ptr< FdmSnapshotCondition const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSnapshotCondition_getTime" "', argument " "1"" of type '" "FdmSnapshotCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmSnapshotCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmSnapshotCondition > * >(argp1);
      arg1 = const_cast< FdmSnapshotCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmSnapshotCondition > * >(argp1);
      arg1 = const_cast< FdmSnapshotCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Time)((FdmSnapshotCondition const *)arg1)->getTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSnapshotCondition_getValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSnapshotCondition *arg1 = (FdmSnapshotCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSnapshotCondition const > tempshared1 ;
  ext::shared_ptr< FdmSnapshotCondition const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSnapshotCondition_getValues" "', argument " "1"" of type '" "FdmSnapshotCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmSnapshotCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmSnapshotCondition > * >(argp1);
      arg1 = const_cast< FdmSnapshotCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmSnapshotCondition > * >(argp1);
      arg1 = const_cast< FdmSnapshotCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &((FdmSnapshotCondition const *)arg1)->getValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmSnapshotCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSnapshotCondition *arg1 = (FdmSnapshotCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSnapshotCondition > tempshared1 ;
  ext::shared_ptr< FdmSnapshotCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSnapshotCondition" "', argument " "1"" of type '" "FdmSnapshotCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmSnapshotCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmSnapshotCondition > * >(argp1);
      arg1 = const_cast< FdmSnapshotCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmSnapshotCondition > * >(argp1);
      arg1 = const_cast< FdmSnapshotCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSnapshotCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSnapshotCondition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_FdmStepConditionVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_iterator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__iterator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___nonzero__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____nonzero__((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___bool__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____bool__((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___len__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____len__((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___getslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___getslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmStepConditionVector___getslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmStepConditionVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg3 ;
  std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___setslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___setslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmStepConditionVector___setslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val3);
  {
    std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *ptr = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FdmStepConditionVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepConditionVector___setslice__" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FdmStepConditionVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_FdmStepConditionVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__setslice__(std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__setslice__(std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type,std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type,std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___delslice__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___delslice__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmStepConditionVector___delslice__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___delitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *)std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *ptr = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmStepConditionVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepConditionVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___delitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_FdmStepConditionVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmStepConditionVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__delitem__(std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___getitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___getitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *) &std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____getitem____SWIG_1((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StepCondition<Array> > *smartresult = *result ? new ext::shared_ptr<  StepCondition<Array> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_FdmStepConditionVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmStepConditionVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__getitem__(std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector___setitem__" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector___setitem__" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmStepConditionVector___setitem__" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< StepCondition< Array > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_FdmStepConditionVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmStepConditionVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmStepConditionVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::__setitem__(std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_pop" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StepCondition<Array> > *smartresult = result ? new ext::shared_ptr<  StepCondition<Array> >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_append" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmStepConditionVector_append" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__append(arg1,(ext::shared_ptr< StepCondition< Array > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmStepConditionVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new std::vector< ext::shared_ptr< StepCondition< Array > > >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmStepConditionVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *ptr = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmStepConditionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmStepConditionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new std::vector< ext::shared_ptr< StepCondition< Array > > >((std::vector< ext::shared_ptr< StepCondition< Array > > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_empty" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_size" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_swap" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmStepConditionVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepConditionVector_swap" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_begin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_end" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_rbegin" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_rend" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_clear" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< ext::shared_ptr< StepCondition< Array > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_get_allocator" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1)->get_allocator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< ext::shared_ptr< StepCondition< Array > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmStepConditionVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmStepConditionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new std::vector< ext::shared_ptr< StepCondition< Array > > >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_pop_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_erase" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_erase" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_erase" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_FdmStepConditionVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_FdmStepConditionVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::erase(std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::erase(std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator,std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_FdmStepConditionVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg1 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdmStepConditionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmStepConditionVector" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > > *)new std::vector< ext::shared_ptr< StepCondition< Array > > >(arg1,(std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmStepConditionVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmStepConditionVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_FdmStepConditionVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FdmStepConditionVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdmStepConditionVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmStepConditionVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmStepConditionVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::vector()\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::vector(std::vector< ext::shared_ptr< StepCondition< Array > > > const &)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::vector(std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::vector(std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_push_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmStepConditionVector_push_back" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_front" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *) &((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StepCondition<Array> > *smartresult = *result ? new ext::shared_ptr<  StepCondition<Array> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_back" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *) &((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StepCondition<Array> > *smartresult = *result ? new ext::shared_ptr<  StepCondition<Array> >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_assign" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector_assign" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmStepConditionVector_assign" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_resize" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector_resize" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmStepConditionVector_resize" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FdmStepConditionVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmStepConditionVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::resize(std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::resize(std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared3 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmStepConditionVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(ext::shared_ptr< StepCondition< Array > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator arg2 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg3 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_insert" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FdmStepConditionVector_insert" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmStepConditionVector_insert" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FdmStepConditionVector_insert" "', argument " "4"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_ext_shared_ptr_Sl_StepCondition_Sl_Array_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(ext::shared_ptr< StepCondition< Array > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FdmStepConditionVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_StepConditionT_Array_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_FdmStepConditionVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FdmStepConditionVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::insert(std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)\n"
    "    std::vector< ext::shared_ptr< StepCondition< Array > > >::insert(std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator,std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type,std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionVector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_reserve" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmStepConditionVector_reserve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionVector_capacity" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      result = ((std::vector< ext::shared_ptr< StepCondition< Array > > > const *)arg1)->capacity();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmStepConditionVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< StepCondition< Array > > > *arg1 = (std::vector< ext::shared_ptr< StepCondition< Array > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmStepConditionVector" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< ext::shared_ptr< StepCondition< Array > > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmStepConditionVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_ext__shared_ptrT_StepConditionT_Array_t_t_std__allocatorT_ext__shared_ptrT_StepConditionT_Array_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmStepConditionVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmStepConditionComposite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  FdmStepConditionComposite *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmStepConditionComposite", 2, 2, swig_obj)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmStepConditionComposite" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmStepConditionComposite" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *ptr = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmStepConditionComposite" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmStepConditionComposite" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (FdmStepConditionComposite *)new_FdmStepConditionComposite((std::vector< double,std::allocator< double > > const &)*arg1,(std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmStepConditionComposite > *smartresult = result ? new ext::shared_ptr<  FdmStepConditionComposite >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionComposite_stoppingTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmStepConditionComposite *arg1 = (FdmStepConditionComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite const > tempshared1 ;
  ext::shared_ptr< FdmStepConditionComposite const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionComposite_stoppingTimes" "', argument " "1"" of type '" "FdmStepConditionComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmStepConditionComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmStepConditionComposite > * >(argp1);
      arg1 = const_cast< FdmStepConditionComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmStepConditionComposite > * >(argp1);
      arg1 = const_cast< FdmStepConditionComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((FdmStepConditionComposite const *)arg1)->stoppingTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionComposite_conditions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmStepConditionComposite *arg1 = (FdmStepConditionComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite const > tempshared1 ;
  ext::shared_ptr< FdmStepConditionComposite const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionComposite_conditions" "', argument " "1"" of type '" "FdmStepConditionComposite const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmStepConditionComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmStepConditionComposite > * >(argp1);
      arg1 = const_cast< FdmStepConditionComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmStepConditionComposite > * >(argp1);
      arg1 = const_cast< FdmStepConditionComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > *) &((FdmStepConditionComposite const *)arg1)->conditions();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< StepCondition< Array > >,std::allocator< ext::shared_ptr< StepCondition< Array > > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionComposite_joinConditions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmSnapshotCondition > *arg1 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSnapshotCondition > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > tempshared2 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< FdmStepConditionComposite > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionComposite_joinConditions", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSnapshotCondition_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionComposite_joinConditions" "', argument " "1"" of type '" "ext::shared_ptr< FdmSnapshotCondition > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmSnapshotCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmSnapshotCondition > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmSnapshotCondition > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmStepConditionComposite_joinConditions" "', argument " "2"" of type '" "ext::shared_ptr< FdmStepConditionComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = FdmStepConditionComposite::joinConditions((ext::shared_ptr< FdmSnapshotCondition > const &)*arg1,(ext::shared_ptr< FdmStepConditionComposite > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmStepConditionComposite > *smartresult = result ? new ext::shared_ptr<  FdmStepConditionComposite >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmStepConditionComposite_vanillaComposite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  ext::shared_ptr< FdmMesher > *arg3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg4 = 0 ;
  Date *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  ext::shared_ptr< FdmStepConditionComposite > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmStepConditionComposite_vanillaComposite", 6, 6, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "3"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "4"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp4) : &tempshared4;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmStepConditionComposite_vanillaComposite" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = FdmStepConditionComposite::vanillaComposite((std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,(ext::shared_ptr< FdmMesher > const &)*arg3,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg4,(Date const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmStepConditionComposite > *smartresult = result ? new ext::shared_ptr<  FdmStepConditionComposite >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmStepConditionComposite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmStepConditionComposite *arg1 = (FdmStepConditionComposite *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > tempshared1 ;
  ext::shared_ptr< FdmStepConditionComposite > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmStepConditionComposite" "', argument " "1"" of type '" "FdmStepConditionComposite *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmStepConditionComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmStepConditionComposite > * >(argp1);
      arg1 = const_cast< FdmStepConditionComposite * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmStepConditionComposite > * >(argp1);
      arg1 = const_cast< FdmStepConditionComposite * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmStepConditionComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmStepConditionComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmAmericanStepCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared2 ;
  PyObject *swig_obj[2] ;
  FdmAmericanStepCondition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmAmericanStepCondition", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmAmericanStepCondition" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmAmericanStepCondition" "', argument " "2"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdmAmericanStepCondition *)new FdmAmericanStepCondition((ext::shared_ptr< FdmMesher > const &)*arg1,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmAmericanStepCondition > *smartresult = result ? new ext::shared_ptr<  FdmAmericanStepCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmAmericanStepCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmAmericanStepCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmAmericanStepCondition *arg1 = (FdmAmericanStepCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmAmericanStepCondition > tempshared1 ;
  ext::shared_ptr< FdmAmericanStepCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmAmericanStepCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmAmericanStepCondition" "', argument " "1"" of type '" "FdmAmericanStepCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmAmericanStepCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmAmericanStepCondition > * >(argp1);
      arg1 = const_cast< FdmAmericanStepCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmAmericanStepCondition > * >(argp1);
      arg1 = const_cast< FdmAmericanStepCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmAmericanStepCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmAmericanStepCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmAmericanStepCondition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmArithmeticAverageCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  ext::shared_ptr< FdmMesher > *arg4 = 0 ;
  Size arg5 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  FdmArithmeticAverageCondition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmArithmeticAverageCondition", 5, 5, swig_obj)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmArithmeticAverageCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmArithmeticAverageCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmArithmeticAverageCondition" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmArithmeticAverageCondition" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmArithmeticAverageCondition" "', argument " "4"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmArithmeticAverageCondition" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdmArithmeticAverageCondition *)new FdmArithmeticAverageCondition((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2,arg3,(ext::shared_ptr< FdmMesher > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmArithmeticAverageCondition > *smartresult = result ? new ext::shared_ptr<  FdmArithmeticAverageCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmArithmeticAverageCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmArithmeticAverageCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmArithmeticAverageCondition *arg1 = (FdmArithmeticAverageCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmArithmeticAverageCondition > tempshared1 ;
  ext::shared_ptr< FdmArithmeticAverageCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmArithmeticAverageCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmArithmeticAverageCondition" "', argument " "1"" of type '" "FdmArithmeticAverageCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmArithmeticAverageCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmArithmeticAverageCondition > * >(argp1);
      arg1 = const_cast< FdmArithmeticAverageCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmArithmeticAverageCondition > * >(argp1);
      arg1 = const_cast< FdmArithmeticAverageCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmArithmeticAverageCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmArithmeticAverageCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmArithmeticAverageCondition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmBermudanStepCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  Date *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  ext::shared_ptr< FdmMesher > *arg4 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared5 ;
  PyObject *swig_obj[5] ;
  FdmBermudanStepCondition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmBermudanStepCondition", 5, 5, swig_obj)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBermudanStepCondition" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBermudanStepCondition" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBermudanStepCondition" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBermudanStepCondition" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmBermudanStepCondition" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBermudanStepCondition" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmBermudanStepCondition" "', argument " "4"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmBermudanStepCondition" "', argument " "5"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (FdmBermudanStepCondition *)new FdmBermudanStepCondition((std::vector< Date,std::allocator< Date > > const &)*arg1,(Date const &)*arg2,(DayCounter const &)*arg3,(ext::shared_ptr< FdmMesher > const &)*arg4,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBermudanStepCondition > *smartresult = result ? new ext::shared_ptr<  FdmBermudanStepCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBermudanStepCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBermudanStepCondition_exerciseTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBermudanStepCondition *arg1 = (FdmBermudanStepCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBermudanStepCondition const > tempshared1 ;
  ext::shared_ptr< FdmBermudanStepCondition const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBermudanStepCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBermudanStepCondition_exerciseTimes" "', argument " "1"" of type '" "FdmBermudanStepCondition const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmBermudanStepCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmBermudanStepCondition > * >(argp1);
      arg1 = const_cast< FdmBermudanStepCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmBermudanStepCondition > * >(argp1);
      arg1 = const_cast< FdmBermudanStepCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((FdmBermudanStepCondition const *)arg1)->exerciseTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmBermudanStepCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBermudanStepCondition *arg1 = (FdmBermudanStepCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBermudanStepCondition > tempshared1 ;
  ext::shared_ptr< FdmBermudanStepCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBermudanStepCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBermudanStepCondition" "', argument " "1"" of type '" "FdmBermudanStepCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBermudanStepCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBermudanStepCondition > * >(argp1);
      arg1 = const_cast< FdmBermudanStepCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBermudanStepCondition > * >(argp1);
      arg1 = const_cast< FdmBermudanStepCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBermudanStepCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBermudanStepCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBermudanStepCondition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSimpleStorageCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg3 = 0 ;
  Real arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared3 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  FdmSimpleStorageCondition *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmSimpleStorageCondition", 4, 4, swig_obj)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSimpleStorageCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmSimpleStorageCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleStorageCondition" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmSimpleStorageCondition" "', argument " "3"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSimpleStorageCondition" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (FdmSimpleStorageCondition *)new FdmSimpleStorageCondition((std::vector< Time,std::allocator< Time > > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleStorageCondition > *smartresult = result ? new ext::shared_ptr<  FdmSimpleStorageCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleStorageCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmSimpleStorageCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSimpleStorageCondition *arg1 = (FdmSimpleStorageCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSimpleStorageCondition > tempshared1 ;
  ext::shared_ptr< FdmSimpleStorageCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSimpleStorageCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSimpleStorageCondition" "', argument " "1"" of type '" "FdmSimpleStorageCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmSimpleStorageCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmSimpleStorageCondition > * >(argp1);
      arg1 = const_cast< FdmSimpleStorageCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmSimpleStorageCondition > * >(argp1);
      arg1 = const_cast< FdmSimpleStorageCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSimpleStorageCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmSimpleStorageCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSimpleStorageCondition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSimpleSwingCondition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdmSimpleSwingCondition *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSimpleSwingCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmSimpleSwingCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleSwingCondition" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmSimpleSwingCondition" "', argument " "3"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSimpleSwingCondition" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSimpleSwingCondition" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdmSimpleSwingCondition *)new FdmSimpleSwingCondition((std::vector< Time,std::allocator< Time > > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleSwingCondition > *smartresult = result ? new ext::shared_ptr<  FdmSimpleSwingCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleSwingCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSimpleSwingCondition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg3 = 0 ;
  Size arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared3 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdmSimpleSwingCondition *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSimpleSwingCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmSimpleSwingCondition" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSimpleSwingCondition" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmSimpleSwingCondition" "', argument " "3"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp3) : &tempshared3;
    }
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdmSimpleSwingCondition" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdmSimpleSwingCondition *)new FdmSimpleSwingCondition((std::vector< Time,std::allocator< Time > > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmSimpleSwingCondition > *smartresult = result ? new ext::shared_ptr<  FdmSimpleSwingCondition >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmSimpleSwingCondition_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmSimpleSwingCondition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmSimpleSwingCondition", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdmSimpleSwingCondition__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdmSimpleSwingCondition__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmSimpleSwingCondition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmSimpleSwingCondition::FdmSimpleSwingCondition(std::vector< Time,std::allocator< Time > > const &,ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< FdmInnerValueCalculator > const &,Size,Size)\n"
    "    FdmSimpleSwingCondition::FdmSimpleSwingCondition(std::vector< Time,std::allocator< Time > > const &,ext::shared_ptr< FdmMesher > const &,ext::shared_ptr< FdmInnerValueCalculator > const &,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdmSimpleSwingCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSimpleSwingCondition *arg1 = (FdmSimpleSwingCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmSimpleSwingCondition > tempshared1 ;
  ext::shared_ptr< FdmSimpleSwingCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmSimpleSwingCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSimpleSwingCondition" "', argument " "1"" of type '" "FdmSimpleSwingCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmSimpleSwingCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmSimpleSwingCondition > * >(argp1);
      arg1 = const_cast< FdmSimpleSwingCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmSimpleSwingCondition > * >(argp1);
      arg1 = const_cast< FdmSimpleSwingCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSimpleSwingCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmSimpleSwingCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSimpleSwingCondition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmDividendHandler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *arg1 = 0 ;
  ext::shared_ptr< FdmMesher > *arg2 = 0 ;
  Date *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  Size arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  FdmDividendHandler *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmDividendHandler", 5, 5, swig_obj)) SWIG_fail;
  {
    std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *ptr = (std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmDividendHandler" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmDividendHandler" "', argument " "1"" of type '" "std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmDividendHandler" "', argument " "2"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmDividendHandler" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmDividendHandler" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmDividendHandler" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmDividendHandler" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmDividendHandler" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdmDividendHandler *)new FdmDividendHandler((std::vector< ext::shared_ptr< Dividend >,std::allocator< ext::shared_ptr< Dividend > > > const &)*arg1,(ext::shared_ptr< FdmMesher > const &)*arg2,(Date const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmDividendHandler > *smartresult = result ? new ext::shared_ptr<  FdmDividendHandler >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmDividendHandler_dividendTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDividendHandler const > tempshared1 ;
  ext::shared_ptr< FdmDividendHandler const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmDividendHandler_dividendTimes" "', argument " "1"" of type '" "FdmDividendHandler const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((FdmDividendHandler const *)arg1)->dividendTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmDividendHandler_dividendDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDividendHandler const > tempshared1 ;
  ext::shared_ptr< FdmDividendHandler const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmDividendHandler_dividendDates" "', argument " "1"" of type '" "FdmDividendHandler const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((FdmDividendHandler const *)arg1)->dividendDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmDividendHandler_dividends(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDividendHandler const > tempshared1 ;
  ext::shared_ptr< FdmDividendHandler const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmDividendHandler_dividends" "', argument " "1"" of type '" "FdmDividendHandler const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((FdmDividendHandler const *)arg1)->dividends();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmDividendHandler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmDividendHandler *arg1 = (FdmDividendHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmDividendHandler > tempshared1 ;
  ext::shared_ptr< FdmDividendHandler > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmDividendHandler" "', argument " "1"" of type '" "FdmDividendHandler *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmDividendHandler > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmDividendHandler > * >(argp1);
      arg1 = const_cast< FdmDividendHandler * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmDividendHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmDividendHandler_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmDividendHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmSolverDesc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmMesher > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > *arg3 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > *arg4 = 0 ;
  Time arg5 ;
  Size arg6 ;
  Size arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmMesher > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< FdmInnerValueCalculator > tempshared4 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  FdmSolverDesc *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmSolverDesc", 7, 7, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmSolverDesc" "', argument " "1"" of type '" "ext::shared_ptr< FdmMesher > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmMesher > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmSolverDesc" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmSolverDesc" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmSolverDesc" "', argument " "3"" of type '" "ext::shared_ptr< FdmStepConditionComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmSolverDesc" "', argument " "4"" of type '" "ext::shared_ptr< FdmInnerValueCalculator > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< FdmInnerValueCalculator > * >(argp4) : &tempshared4;
    }
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdmSolverDesc" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FdmSolverDesc" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FdmSolverDesc" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FdmSolverDesc *)new_FdmSolverDesc((ext::shared_ptr< FdmMesher > const &)*arg1,(std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > const &)*arg2,(ext::shared_ptr< FdmStepConditionComposite > const &)*arg3,(ext::shared_ptr< FdmInnerValueCalculator > const &)*arg4,arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getMesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FdmMesher > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getMesher" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = FdmSolverDesc_getMesher((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmMesher > *smartresult = result ? new ext::shared_ptr<  FdmMesher >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmMesher_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getBcSet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FdmBoundaryConditionSet *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getBcSet" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = (FdmBoundaryConditionSet *) &FdmSolverDesc_getBcSet((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getStepConditions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FdmStepConditionComposite > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getStepConditions" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = FdmSolverDesc_getStepConditions((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmStepConditionComposite > *smartresult = result ? new ext::shared_ptr<  FdmStepConditionComposite >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FdmInnerValueCalculator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getCalculator" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = FdmSolverDesc_getCalculator((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmInnerValueCalculator > *smartresult = result ? new ext::shared_ptr<  FdmInnerValueCalculator >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmInnerValueCalculator_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getMaturity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getMaturity" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = (Time)FdmSolverDesc_getMaturity((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getTimeSteps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getTimeSteps" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = FdmSolverDesc_getTimeSteps((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmSolverDesc_getDampingSteps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmSolverDesc_getDampingSteps" "', argument " "1"" of type '" "FdmSolverDesc const *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      result = FdmSolverDesc_getDampingSteps((FdmSolverDesc const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmSolverDesc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = (FdmSolverDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmSolverDesc" "', argument " "1"" of type '" "FdmSolverDesc *""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmSolverDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FdmSolverDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmSolverDesc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm1DimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  PyObject *swig_obj[3] ;
  Fdm1DimSolver *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Fdm1DimSolver", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm1DimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm1DimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm1DimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm1DimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSchemeDesc * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm1DimSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (Fdm1DimSolver *)new Fdm1DimSolver((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1DimSolver > *smartresult = result ? new ext::shared_ptr<  Fdm1DimSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1DimSolver_interpolateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1DimSolver_interpolateAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1DimSolver_interpolateAt" "', argument " "1"" of type '" "Fdm1DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1DimSolver_interpolateAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->interpolateAt(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1DimSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1DimSolver_thetaAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1DimSolver_thetaAt" "', argument " "1"" of type '" "Fdm1DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1DimSolver_thetaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->thetaAt(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1DimSolver_derivativeX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1DimSolver_derivativeX", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1DimSolver_derivativeX" "', argument " "1"" of type '" "Fdm1DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1DimSolver_derivativeX" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->derivativeX(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm1DimSolver_derivativeXX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm1DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm1DimSolver_derivativeXX", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm1DimSolver_derivativeXX" "', argument " "1"" of type '" "Fdm1DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm1DimSolver_derivativeXX" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((Fdm1DimSolver const *)arg1)->derivativeXX(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm1DimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm1DimSolver *arg1 = (Fdm1DimSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm1DimSolver > tempshared1 ;
  ext::shared_ptr< Fdm1DimSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm1DimSolver" "', argument " "1"" of type '" "Fdm1DimSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm1DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm1DimSolver > * >(argp1);
      arg1 = const_cast< Fdm1DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm1DimSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fdm1DimSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm1DimSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmBackwardSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmLinearOpComposite > *arg1 = 0 ;
  FdmBoundaryConditionSet *arg2 = 0 ;
  ext::shared_ptr< FdmStepConditionComposite > arg3 ;
  FdmSchemeDesc *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  FdmBackwardSolver *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmBackwardSolver", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmBackwardSolver" "', argument " "1"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *ptr = (std::vector< ext::shared_ptr< FdmBoundaryCondition >,std::allocator< ext::shared_ptr< FdmBoundaryCondition > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmBackwardSolver" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBackwardSolver" "', argument " "2"" of type '" "FdmBoundaryConditionSet const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmStepConditionComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmBackwardSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmStepConditionComposite > const""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< FdmStepConditionComposite > * >(argp3);
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmBackwardSolver" "', argument " "4"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmBackwardSolver" "', argument " "4"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg4 = reinterpret_cast< FdmSchemeDesc * >(argp4);
  {
    try {
      result = (FdmBackwardSolver *)new FdmBackwardSolver((ext::shared_ptr< FdmLinearOpComposite > const &)*arg1,(FdmBoundaryConditionSet const &)*arg2,arg3,(FdmSchemeDesc const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmBackwardSolver > *smartresult = result ? new ext::shared_ptr<  FdmBackwardSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmBackwardSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmBackwardSolver_rollback(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBackwardSolver *arg1 = (FdmBackwardSolver *) 0 ;
  Array *arg2 = 0 ;
  Time arg3 ;
  Time arg4 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBackwardSolver > tempshared1 ;
  ext::shared_ptr< FdmBackwardSolver > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmBackwardSolver_rollback", 6, 6, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBackwardSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmBackwardSolver_rollback" "', argument " "1"" of type '" "FdmBackwardSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBackwardSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBackwardSolver > * >(argp1);
      arg1 = const_cast< FdmBackwardSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBackwardSolver > * >(argp1);
      arg1 = const_cast< FdmBackwardSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdmBackwardSolver_rollback" "', argument " "2"" of type '" "Array &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FdmBackwardSolver_rollback" "', argument " "2"" of type '" "Array &""'"); 
  }
  arg2 = reinterpret_cast< Array * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmBackwardSolver_rollback" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmBackwardSolver_rollback" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FdmBackwardSolver_rollback" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FdmBackwardSolver_rollback" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      (arg1)->rollback(*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmBackwardSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmBackwardSolver *arg1 = (FdmBackwardSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmBackwardSolver > tempshared1 ;
  ext::shared_ptr< FdmBackwardSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmBackwardSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmBackwardSolver" "', argument " "1"" of type '" "FdmBackwardSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmBackwardSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmBackwardSolver > * >(argp1);
      arg1 = const_cast< FdmBackwardSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmBackwardSolver > * >(argp1);
      arg1 = const_cast< FdmBackwardSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmBackwardSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmBackwardSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmBackwardSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm2dBlackScholesSolver(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg2 = 0 ;
  Real arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  FdmSchemeDesc const &arg5_defvalue = FdmSchemeDesc::Hundsdorfer() ;
  FdmSchemeDesc *arg5 = (FdmSchemeDesc *) &arg5_defvalue ;
  bool arg6 = (bool) false ;
  Real arg7 = (Real) -Null< Real >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"p1",  (char *)"p2",  (char *)"correlation",  (char *)"solverDesc",  (char *)"schemeDesc",  (char *)"localVol",  (char *)"illegalLocalVolOverwrite",  NULL 
  };
  Fdm2dBlackScholesSolver *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:new_Fdm2dBlackScholesSolver", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "2"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "4"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "4"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg4 = reinterpret_cast< FdmSolverDesc * >(argp4);
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
    }
    arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_bool(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "6"" of type '" "bool""'");
    } 
    arg6 = static_cast< bool >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Fdm2dBlackScholesSolver" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  {
    try {
      result = (Fdm2dBlackScholesSolver *)new_Fdm2dBlackScholesSolver((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*arg4,(FdmSchemeDesc const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm2dBlackScholesSolver > *smartresult = result ? new ext::shared_ptr<  Fdm2dBlackScholesSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_valueAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_valueAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_valueAt" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_valueAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_valueAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->valueAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_thetaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_thetaAt" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_thetaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_thetaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->thetaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_deltaXat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_deltaXat", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_deltaXat" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_deltaXat" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_deltaXat" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->deltaXat(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_deltaYat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_deltaYat", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_deltaYat" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_deltaYat" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_deltaYat" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->deltaYat(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_gammaXat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_gammaXat", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_gammaXat" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_gammaXat" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_gammaXat" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->gammaXat(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_gammaYat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_gammaYat", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_gammaYat" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_gammaYat" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_gammaYat" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->gammaYat(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2dBlackScholesSolver_gammaXYat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2dBlackScholesSolver_gammaXYat", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2dBlackScholesSolver_gammaXYat" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2dBlackScholesSolver_gammaXYat" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2dBlackScholesSolver_gammaXYat" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2dBlackScholesSolver const *)arg1)->gammaXYat(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm2dBlackScholesSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2dBlackScholesSolver *arg1 = (Fdm2dBlackScholesSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver > tempshared1 ;
  ext::shared_ptr< Fdm2dBlackScholesSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm2dBlackScholesSolver" "', argument " "1"" of type '" "Fdm2dBlackScholesSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm2dBlackScholesSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm2dBlackScholesSolver > * >(argp1);
      arg1 = const_cast< Fdm2dBlackScholesSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm2dBlackScholesSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fdm2dBlackScholesSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm2dBlackScholesSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm2DimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  PyObject *swig_obj[3] ;
  Fdm2DimSolver *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Fdm2DimSolver", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm2DimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm2DimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm2DimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm2DimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSchemeDesc * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm2DimSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (Fdm2DimSolver *)new Fdm2DimSolver((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm2DimSolver > *smartresult = result ? new ext::shared_ptr<  Fdm2DimSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_interpolateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_interpolateAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_interpolateAt" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_interpolateAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_interpolateAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->interpolateAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_thetaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_thetaAt" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_thetaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_thetaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->thetaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_derivativeX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_derivativeX", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_derivativeX" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_derivativeX" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_derivativeX" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeX(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_derivativeY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_derivativeY", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_derivativeY" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_derivativeY" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_derivativeY" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeY(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_derivativeXX(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_derivativeXX", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_derivativeXX" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_derivativeXX" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_derivativeXX" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeXX(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_derivativeYY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_derivativeYY", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_derivativeYY" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_derivativeYY" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_derivativeYY" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeYY(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm2DimSolver_derivativeXY(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm2DimSolver_derivativeXY", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm2DimSolver_derivativeXY" "', argument " "1"" of type '" "Fdm2DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm2DimSolver_derivativeXY" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm2DimSolver_derivativeXY" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Fdm2DimSolver const *)arg1)->derivativeXY(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm2DimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm2DimSolver *arg1 = (Fdm2DimSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm2DimSolver > tempshared1 ;
  ext::shared_ptr< Fdm2DimSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm2DimSolver" "', argument " "1"" of type '" "Fdm2DimSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm2DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm2DimSolver > * >(argp1);
      arg1 = const_cast< Fdm2DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm2DimSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fdm2DimSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm2DimSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm3DimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  PyObject *swig_obj[3] ;
  Fdm3DimSolver *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Fdm3DimSolver", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm3DimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm3DimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm3DimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm3DimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSchemeDesc * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm3DimSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (Fdm3DimSolver *)new Fdm3DimSolver((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm3DimSolver > *smartresult = result ? new ext::shared_ptr<  Fdm3DimSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm3DimSolver_performCalculations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm3DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm3DimSolver const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm3DimSolver_performCalculations" "', argument " "1"" of type '" "Fdm3DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      ((Fdm3DimSolver const *)arg1)->performCalculations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm3DimSolver_interpolateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm3DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm3DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm3DimSolver_interpolateAt", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm3DimSolver_interpolateAt" "', argument " "1"" of type '" "Fdm3DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm3DimSolver_interpolateAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm3DimSolver_interpolateAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fdm3DimSolver_interpolateAt" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((Fdm3DimSolver const *)arg1)->interpolateAt(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm3DimSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm3DimSolver const > tempshared1 ;
  ext::shared_ptr< Fdm3DimSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm3DimSolver_thetaAt", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm3DimSolver_thetaAt" "', argument " "1"" of type '" "Fdm3DimSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Fdm3DimSolver_thetaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Fdm3DimSolver_thetaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Fdm3DimSolver_thetaAt" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((Fdm3DimSolver const *)arg1)->thetaAt(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm3DimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Fdm3DimSolver *arg1 = (Fdm3DimSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Fdm3DimSolver > tempshared1 ;
  ext::shared_ptr< Fdm3DimSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm3DimSolver" "', argument " "1"" of type '" "Fdm3DimSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Fdm3DimSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Fdm3DimSolver > * >(argp1);
      arg1 = const_cast< Fdm3DimSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm3DimSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Fdm3DimSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm3DimSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmG2Solver__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FdmG2Solver *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmG2Solver" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmG2Solver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmG2Solver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSolverDesc * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmG2Solver" "', argument " "3"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmG2Solver" "', argument " "3"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg3 = reinterpret_cast< FdmSchemeDesc * >(argp3);
  {
    try {
      result = (FdmG2Solver *)new_FdmG2Solver__SWIG_0((ext::shared_ptr< G2 > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmG2Solver > *smartresult = result ? new ext::shared_ptr<  FdmG2Solver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmG2Solver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmG2Solver__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< G2 > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< G2 > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FdmG2Solver *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_G2_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmG2Solver" "', argument " "1"" of type '" "ext::shared_ptr< G2 > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< G2 > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< G2 > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmG2Solver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmG2Solver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSolverDesc * >(argp2);
  {
    try {
      result = (FdmG2Solver *)new_FdmG2Solver__SWIG_0((ext::shared_ptr< G2 > const &)*arg1,(FdmSolverDesc const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmG2Solver > *smartresult = result ? new ext::shared_ptr<  FdmG2Solver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmG2Solver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmG2Solver(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmG2Solver", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmG2Solver__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_G2_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdmG2Solver__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmG2Solver'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmG2Solver::FdmG2Solver(ext::shared_ptr< G2 > const &,FdmSolverDesc const &,FdmSchemeDesc const &)\n"
    "    FdmG2Solver::FdmG2Solver(ext::shared_ptr< G2 > const &,FdmSolverDesc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmG2Solver_valueAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmG2Solver *arg1 = (FdmG2Solver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmG2Solver const > tempshared1 ;
  ext::shared_ptr< FdmG2Solver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmG2Solver_valueAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmG2Solver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmG2Solver_valueAt" "', argument " "1"" of type '" "FdmG2Solver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmG2Solver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmG2Solver > * >(argp1);
      arg1 = const_cast< FdmG2Solver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmG2Solver > * >(argp1);
      arg1 = const_cast< FdmG2Solver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmG2Solver_valueAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmG2Solver_valueAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmG2Solver const *)arg1)->valueAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmG2Solver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmG2Solver *arg1 = (FdmG2Solver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmG2Solver > tempshared1 ;
  ext::shared_ptr< FdmG2Solver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmG2Solver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmG2Solver" "', argument " "1"" of type '" "FdmG2Solver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmG2Solver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmG2Solver > * >(argp1);
      arg1 = const_cast< FdmG2Solver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmG2Solver > * >(argp1);
      arg1 = const_cast< FdmG2Solver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmG2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmG2Solver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmG2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonHullWhiteSolver__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > *arg2 = 0 ;
  Rate arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  FdmSchemeDesc *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HullWhiteProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FdmHestonHullWhiteSolver *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "4"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "4"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg4 = reinterpret_cast< FdmSolverDesc * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "5"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg5 = reinterpret_cast< FdmSchemeDesc * >(argp5);
  {
    try {
      result = (FdmHestonHullWhiteSolver *)new_FdmHestonHullWhiteSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< HullWhiteProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*arg4,(FdmSchemeDesc const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonHullWhiteSolver > *smartresult = result ? new ext::shared_ptr<  FdmHestonHullWhiteSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonHullWhiteSolver__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< HullWhiteProcess > *arg2 = 0 ;
  Rate arg3 ;
  FdmSolverDesc *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HullWhiteProcess > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FdmHestonHullWhiteSolver *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "2"" of type '" "ext::shared_ptr< HullWhiteProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HullWhiteProcess > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "4"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHestonHullWhiteSolver" "', argument " "4"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg4 = reinterpret_cast< FdmSolverDesc * >(argp4);
  {
    try {
      result = (FdmHestonHullWhiteSolver *)new_FdmHestonHullWhiteSolver__SWIG_0((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< HullWhiteProcess > const &)*arg2,arg3,(FdmSolverDesc const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonHullWhiteSolver > *smartresult = result ? new ext::shared_ptr<  FdmHestonHullWhiteSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHestonHullWhiteSolver(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmHestonHullWhiteSolver", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FdmHestonHullWhiteSolver__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhiteProcess_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FdmHestonHullWhiteSolver__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmHestonHullWhiteSolver'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmHestonHullWhiteSolver::FdmHestonHullWhiteSolver(ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< HullWhiteProcess > const &,Rate,FdmSolverDesc const &,FdmSchemeDesc const &)\n"
    "    FdmHestonHullWhiteSolver::FdmHestonHullWhiteSolver(ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< HullWhiteProcess > const &,Rate,FdmSolverDesc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmHestonHullWhiteSolver_valueAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonHullWhiteSolver_valueAt", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonHullWhiteSolver_valueAt" "', argument " "1"" of type '" "FdmHestonHullWhiteSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonHullWhiteSolver_valueAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonHullWhiteSolver_valueAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmHestonHullWhiteSolver_valueAt" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->valueAt(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonHullWhiteSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonHullWhiteSolver_thetaAt", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonHullWhiteSolver_thetaAt" "', argument " "1"" of type '" "FdmHestonHullWhiteSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonHullWhiteSolver_thetaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonHullWhiteSolver_thetaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmHestonHullWhiteSolver_thetaAt" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->thetaAt(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonHullWhiteSolver_deltaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonHullWhiteSolver_deltaAt", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonHullWhiteSolver_deltaAt" "', argument " "1"" of type '" "FdmHestonHullWhiteSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonHullWhiteSolver_deltaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonHullWhiteSolver_deltaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmHestonHullWhiteSolver_deltaAt" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FdmHestonHullWhiteSolver_deltaAt" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->deltaAt(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonHullWhiteSolver_gammaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Rate arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonHullWhiteSolver_gammaAt", 5, 5, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonHullWhiteSolver_gammaAt" "', argument " "1"" of type '" "FdmHestonHullWhiteSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonHullWhiteSolver_gammaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonHullWhiteSolver_gammaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FdmHestonHullWhiteSolver_gammaAt" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FdmHestonHullWhiteSolver_gammaAt" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)((FdmHestonHullWhiteSolver const *)arg1)->gammaAt(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonHullWhiteSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonHullWhiteSolver *arg1 = (FdmHestonHullWhiteSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver > tempshared1 ;
  ext::shared_ptr< FdmHestonHullWhiteSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonHullWhiteSolver" "', argument " "1"" of type '" "FdmHestonHullWhiteSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHestonHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonHullWhiteSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonHullWhiteSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonHullWhiteSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHestonSolver(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc const &arg3_defvalue = FdmSchemeDesc::Hundsdorfer() ;
  FdmSchemeDesc *arg3 = (FdmSchemeDesc *) &arg3_defvalue ;
  ext::shared_ptr< FdmQuantoHelper > const &arg4_defvalue = ext::shared_ptr< FdmQuantoHelper >() ;
  ext::shared_ptr< FdmQuantoHelper > *arg4 = (ext::shared_ptr< FdmQuantoHelper > *) &arg4_defvalue ;
  ext::shared_ptr< LocalVolTermStructure > const &arg5_defvalue = ext::shared_ptr< LocalVolTermStructure >() ;
  ext::shared_ptr< LocalVolTermStructure > *arg5 = (ext::shared_ptr< LocalVolTermStructure > *) &arg5_defvalue ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< FdmQuantoHelper > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared5 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"process",  (char *)"solverDesc",  (char *)"schemeDesc",  (char *)"quantoHelper",  (char *)"leverageFct",  NULL 
  };
  FdmHestonSolver *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:new_FdmHestonSolver", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHestonSolver" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHestonSolver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHestonSolver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSolverDesc * >(argp2);
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHestonSolver" "', argument " "3"" of type '" "FdmSchemeDesc const &""'"); 
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHestonSolver" "', argument " "3"" of type '" "FdmSchemeDesc const &""'"); 
    }
    arg3 = reinterpret_cast< FdmSchemeDesc * >(argp3);
  }
  if (obj3) {
    {
      int newmem = 0;
      res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_FdmQuantoHelper_t,  0 , &newmem);
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdmHestonSolver" "', argument " "4"" of type '" "ext::shared_ptr< FdmQuantoHelper > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp4);
        delete reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp4);
        arg4 = &tempshared4;
      } else {
        arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< FdmQuantoHelper > * >(argp4) : &tempshared4;
      }
    }
  }
  if (obj4) {
    {
      int newmem = 0;
      res5 = SWIG_ConvertPtrAndOwn(obj4, &argp5, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
      if (!SWIG_IsOK(res5)) {
        SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FdmHestonSolver" "', argument " "5"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
      }
      if (newmem & SWIG_CAST_NEW_MEMORY) {
        if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5);
        delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5);
        arg5 = &tempshared5;
      } else {
        arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp5) : &tempshared5;
      }
    }
  }
  {
    try {
      result = (FdmHestonSolver *)new_FdmHestonSolver((ext::shared_ptr< HestonProcess > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc const &)*arg3,(ext::shared_ptr< FdmQuantoHelper > const &)*arg4,(ext::shared_ptr< LocalVolTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHestonSolver > *smartresult = result ? new ext::shared_ptr<  FdmHestonSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonSolver_valueAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonSolver_valueAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonSolver_valueAt" "', argument " "1"" of type '" "FdmHestonSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonSolver_valueAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonSolver_valueAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->valueAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonSolver_thetaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonSolver_thetaAt" "', argument " "1"" of type '" "FdmHestonSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonSolver_thetaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonSolver_thetaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->thetaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonSolver_deltaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonSolver_deltaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonSolver_deltaAt" "', argument " "1"" of type '" "FdmHestonSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonSolver_deltaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonSolver_deltaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->deltaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonSolver_gammaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonSolver_gammaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonSolver_gammaAt" "', argument " "1"" of type '" "FdmHestonSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonSolver_gammaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonSolver_gammaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->gammaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonSolver_meanVarianceDeltaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonSolver_meanVarianceDeltaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonSolver_meanVarianceDeltaAt" "', argument " "1"" of type '" "FdmHestonSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonSolver_meanVarianceDeltaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonSolver_meanVarianceDeltaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->meanVarianceDeltaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmHestonSolver_meanVarianceGammaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver const > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHestonSolver_meanVarianceGammaAt", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHestonSolver_meanVarianceGammaAt" "', argument " "1"" of type '" "FdmHestonSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHestonSolver_meanVarianceGammaAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdmHestonSolver_meanVarianceGammaAt" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((FdmHestonSolver const *)arg1)->meanVarianceGammaAt(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHestonSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonSolver *arg1 = (FdmHestonSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHestonSolver > tempshared1 ;
  ext::shared_ptr< FdmHestonSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonSolver" "', argument " "1"" of type '" "FdmHestonSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHestonSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHestonSolver > * >(argp1);
      arg1 = const_cast< FdmHestonSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHestonSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHestonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmHullWhiteSolver__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  FdmSchemeDesc *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FdmHullWhiteSolver *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHullWhiteSolver" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHullWhiteSolver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHullWhiteSolver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSolverDesc * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FdmHullWhiteSolver" "', argument " "3"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHullWhiteSolver" "', argument " "3"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg3 = reinterpret_cast< FdmSchemeDesc * >(argp3);
  {
    try {
      result = (FdmHullWhiteSolver *)new_FdmHullWhiteSolver__SWIG_0((ext::shared_ptr< HullWhite > const &)*arg1,(FdmSolverDesc const &)*arg2,(FdmSchemeDesc const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHullWhiteSolver > *smartresult = result ? new ext::shared_ptr<  FdmHullWhiteSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHullWhiteSolver__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HullWhite > *arg1 = 0 ;
  FdmSolverDesc *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HullWhite > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FdmHullWhiteSolver *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmHullWhiteSolver" "', argument " "1"" of type '" "ext::shared_ptr< HullWhite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HullWhite > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdmHullWhiteSolver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdmHullWhiteSolver" "', argument " "2"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSolverDesc * >(argp2);
  {
    try {
      result = (FdmHullWhiteSolver *)new_FdmHullWhiteSolver__SWIG_0((ext::shared_ptr< HullWhite > const &)*arg1,(FdmSolverDesc const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmHullWhiteSolver > *smartresult = result ? new ext::shared_ptr<  FdmHullWhiteSolver >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteSolver_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdmHullWhiteSolver(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdmHullWhiteSolver", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdmHullWhiteSolver__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HullWhite_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FdmSolverDesc, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FdmHullWhiteSolver__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdmHullWhiteSolver'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdmHullWhiteSolver::FdmHullWhiteSolver(ext::shared_ptr< HullWhite > const &,FdmSolverDesc const &,FdmSchemeDesc const &)\n"
    "    FdmHullWhiteSolver::FdmHullWhiteSolver(ext::shared_ptr< HullWhite > const &,FdmSolverDesc const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FdmHullWhiteSolver_valueAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHullWhiteSolver *arg1 = (FdmHullWhiteSolver *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHullWhiteSolver const > tempshared1 ;
  ext::shared_ptr< FdmHullWhiteSolver const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "FdmHullWhiteSolver_valueAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmHullWhiteSolver_valueAt" "', argument " "1"" of type '" "FdmHullWhiteSolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FdmHullWhiteSolver_valueAt" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((FdmHullWhiteSolver const *)arg1)->valueAt(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmHullWhiteSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHullWhiteSolver *arg1 = (FdmHullWhiteSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmHullWhiteSolver > tempshared1 ;
  ext::shared_ptr< FdmHullWhiteSolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteSolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHullWhiteSolver" "', argument " "1"" of type '" "FdmHullWhiteSolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmHullWhiteSolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHullWhiteSolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmHullWhiteSolver > * >(argp1);
      arg1 = const_cast< FdmHullWhiteSolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHullWhiteSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmHullWhiteSolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmHullWhiteSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm4dimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  PyObject *swig_obj[3] ;
  FdmNdimSolver< 4 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Fdm4dimSolver", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm4dimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm4dimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm4dimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm4dimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSchemeDesc * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm4dimSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdmNdimSolver< 4 > *)new FdmNdimSolver< 4 >((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmNdimSolver<4> > *smartresult = result ? new ext::shared_ptr<  FdmNdimSolver<4> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm4dimSolver_interpolateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 4 > *arg1 = (FdmNdimSolver< 4 > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 4 > const > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 4 > const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm4dimSolver_interpolateAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm4dimSolver_interpolateAt" "', argument " "1"" of type '" "FdmNdimSolver< 4 > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<4> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<4> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 4 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<4> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 4 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm4dimSolver_interpolateAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm4dimSolver_interpolateAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Real)((FdmNdimSolver< 4 > const *)arg1)->interpolateAt((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm4dimSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 4 > *arg1 = (FdmNdimSolver< 4 > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 4 > const > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 4 > const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm4dimSolver_thetaAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm4dimSolver_thetaAt" "', argument " "1"" of type '" "FdmNdimSolver< 4 > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<4> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<4> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 4 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<4> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 4 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm4dimSolver_thetaAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm4dimSolver_thetaAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Real)((FdmNdimSolver< 4 > const *)arg1)->thetaAt((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm4dimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 4 > *arg1 = (FdmNdimSolver< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 4 > > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 4 > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm4dimSolver" "', argument " "1"" of type '" "FdmNdimSolver< 4 > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<4> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<4> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 4 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<4> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 4 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm4dimSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_4_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm4dimSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm5dimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  PyObject *swig_obj[3] ;
  FdmNdimSolver< 5 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Fdm5dimSolver", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm5dimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm5dimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm5dimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm5dimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSchemeDesc * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm5dimSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdmNdimSolver< 5 > *)new FdmNdimSolver< 5 >((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmNdimSolver<5> > *smartresult = result ? new ext::shared_ptr<  FdmNdimSolver<5> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm5dimSolver_interpolateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 5 > *arg1 = (FdmNdimSolver< 5 > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 5 > const > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 5 > const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm5dimSolver_interpolateAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm5dimSolver_interpolateAt" "', argument " "1"" of type '" "FdmNdimSolver< 5 > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<5> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<5> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 5 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<5> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 5 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm5dimSolver_interpolateAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm5dimSolver_interpolateAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Real)((FdmNdimSolver< 5 > const *)arg1)->interpolateAt((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm5dimSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 5 > *arg1 = (FdmNdimSolver< 5 > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 5 > const > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 5 > const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm5dimSolver_thetaAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm5dimSolver_thetaAt" "', argument " "1"" of type '" "FdmNdimSolver< 5 > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<5> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<5> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 5 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<5> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 5 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm5dimSolver_thetaAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm5dimSolver_thetaAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Real)((FdmNdimSolver< 5 > const *)arg1)->thetaAt((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm5dimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 5 > *arg1 = (FdmNdimSolver< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 5 > > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 5 > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm5dimSolver" "', argument " "1"" of type '" "FdmNdimSolver< 5 > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<5> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<5> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 5 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<5> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 5 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm5dimSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_5_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm5dimSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Fdm6dimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmSolverDesc *arg1 = 0 ;
  FdmSchemeDesc *arg2 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< FdmLinearOpComposite > tempshared3 ;
  PyObject *swig_obj[3] ;
  FdmNdimSolver< 6 > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Fdm6dimSolver", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_FdmSolverDesc,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Fdm6dimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm6dimSolver" "', argument " "1"" of type '" "FdmSolverDesc const &""'"); 
  }
  arg1 = reinterpret_cast< FdmSolverDesc * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Fdm6dimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Fdm6dimSolver" "', argument " "2"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg2 = reinterpret_cast< FdmSchemeDesc * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpComposite_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Fdm6dimSolver" "', argument " "3"" of type '" "ext::shared_ptr< FdmLinearOpComposite > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpComposite > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (FdmNdimSolver< 6 > *)new FdmNdimSolver< 6 >((FdmSolverDesc const &)*arg1,(FdmSchemeDesc const &)*arg2,(ext::shared_ptr< FdmLinearOpComposite > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmNdimSolver<6> > *smartresult = result ? new ext::shared_ptr<  FdmNdimSolver<6> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm6dimSolver_interpolateAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 6 > *arg1 = (FdmNdimSolver< 6 > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 6 > const > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 6 > const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm6dimSolver_interpolateAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm6dimSolver_interpolateAt" "', argument " "1"" of type '" "FdmNdimSolver< 6 > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<6> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<6> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 6 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<6> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 6 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm6dimSolver_interpolateAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm6dimSolver_interpolateAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Real)((FdmNdimSolver< 6 > const *)arg1)->interpolateAt((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Fdm6dimSolver_thetaAt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 6 > *arg1 = (FdmNdimSolver< 6 > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 6 > const > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 6 > const > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Fdm6dimSolver_thetaAt", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Fdm6dimSolver_thetaAt" "', argument " "1"" of type '" "FdmNdimSolver< 6 > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<6> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<6> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 6 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmNdimSolver<6> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 6 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Fdm6dimSolver_thetaAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Fdm6dimSolver_thetaAt" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Real)((FdmNdimSolver< 6 > const *)arg1)->thetaAt((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Fdm6dimSolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmNdimSolver< 6 > *arg1 = (FdmNdimSolver< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmNdimSolver< 6 > > tempshared1 ;
  ext::shared_ptr< FdmNdimSolver< 6 > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Fdm6dimSolver" "', argument " "1"" of type '" "FdmNdimSolver< 6 > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<6> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<6> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 6 > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmNdimSolver<6> > * >(argp1);
      arg1 = const_cast< FdmNdimSolver< 6 > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Fdm6dimSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmNdimSolverT_6_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Fdm6dimSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdmIndicesOnBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FdmLinearOpLayout > *arg1 = 0 ;
  Size arg2 ;
  FdmDirichletBoundary::Side arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmLinearOpLayout > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  FdmIndicesOnBoundary *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_FdmIndicesOnBoundary", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmLinearOpLayout_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdmIndicesOnBoundary" "', argument " "1"" of type '" "ext::shared_ptr< FdmLinearOpLayout > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FdmLinearOpLayout > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FdmLinearOpLayout > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FdmLinearOpLayout > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdmIndicesOnBoundary" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdmIndicesOnBoundary" "', argument " "3"" of type '" "FdmDirichletBoundary::Side""'");
  } 
  arg3 = static_cast< FdmDirichletBoundary::Side >(val3);
  {
    try {
      result = (FdmIndicesOnBoundary *)new FdmIndicesOnBoundary((ext::shared_ptr< FdmLinearOpLayout > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdmIndicesOnBoundary > *smartresult = result ? new ext::shared_ptr<  FdmIndicesOnBoundary >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdmIndicesOnBoundary_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FdmIndicesOnBoundary_getIndices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmIndicesOnBoundary *arg1 = (FdmIndicesOnBoundary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmIndicesOnBoundary const > tempshared1 ;
  ext::shared_ptr< FdmIndicesOnBoundary const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmIndicesOnBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdmIndicesOnBoundary_getIndices" "', argument " "1"" of type '" "FdmIndicesOnBoundary const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FdmIndicesOnBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FdmIndicesOnBoundary > * >(argp1);
      arg1 = const_cast< FdmIndicesOnBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FdmIndicesOnBoundary > * >(argp1);
      arg1 = const_cast< FdmIndicesOnBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = FdmIndicesOnBoundary_getIndices((FdmIndicesOnBoundary const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FdmIndicesOnBoundary(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmIndicesOnBoundary *arg1 = (FdmIndicesOnBoundary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdmIndicesOnBoundary > tempshared1 ;
  ext::shared_ptr< FdmIndicesOnBoundary > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdmIndicesOnBoundary_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmIndicesOnBoundary" "', argument " "1"" of type '" "FdmIndicesOnBoundary *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdmIndicesOnBoundary > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdmIndicesOnBoundary > * >(argp1);
      arg1 = const_cast< FdmIndicesOnBoundary * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdmIndicesOnBoundary > * >(argp1);
      arg1 = const_cast< FdmIndicesOnBoundary * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmIndicesOnBoundary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdmIndicesOnBoundary_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdmIndicesOnBoundary_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RiskNeutralDensityCalculator_pdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > tempshared1 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskNeutralDensityCalculator_pdf", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskNeutralDensityCalculator_pdf" "', argument " "1"" of type '" "RiskNeutralDensityCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskNeutralDensityCalculator_pdf" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RiskNeutralDensityCalculator_pdf" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((RiskNeutralDensityCalculator const *)arg1)->pdf(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskNeutralDensityCalculator_cdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > tempshared1 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskNeutralDensityCalculator_cdf", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskNeutralDensityCalculator_cdf" "', argument " "1"" of type '" "RiskNeutralDensityCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskNeutralDensityCalculator_cdf" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RiskNeutralDensityCalculator_cdf" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((RiskNeutralDensityCalculator const *)arg1)->cdf(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskNeutralDensityCalculator_invcdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  Real arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > tempshared1 ;
  ext::shared_ptr< RiskNeutralDensityCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskNeutralDensityCalculator_invcdf", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskNeutralDensityCalculator_invcdf" "', argument " "1"" of type '" "RiskNeutralDensityCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskNeutralDensityCalculator_invcdf" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RiskNeutralDensityCalculator_invcdf" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((RiskNeutralDensityCalculator const *)arg1)->invcdf(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RiskNeutralDensityCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskNeutralDensityCalculator *arg1 = (RiskNeutralDensityCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< RiskNeutralDensityCalculator > tempshared1 ;
  ext::shared_ptr< RiskNeutralDensityCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RiskNeutralDensityCalculator" "', argument " "1"" of type '" "RiskNeutralDensityCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  RiskNeutralDensityCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  RiskNeutralDensityCalculator > * >(argp1);
      arg1 = const_cast< RiskNeutralDensityCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RiskNeutralDensityCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BSMRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  BSMRNDCalculator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BSMRNDCalculator" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (BSMRNDCalculator *)new BSMRNDCalculator((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BSMRNDCalculator > *smartresult = result ? new ext::shared_ptr<  BSMRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BSMRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BSMRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BSMRNDCalculator *arg1 = (BSMRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BSMRNDCalculator > tempshared1 ;
  ext::shared_ptr< BSMRNDCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BSMRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BSMRNDCalculator" "', argument " "1"" of type '" "BSMRNDCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BSMRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BSMRNDCalculator > * >(argp1);
      arg1 = const_cast< BSMRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BSMRNDCalculator > * >(argp1);
      arg1 = const_cast< BSMRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BSMRNDCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BSMRNDCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BSMRNDCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CEVRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  CEVRNDCalculator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_CEVRNDCalculator", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CEVRNDCalculator" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CEVRNDCalculator" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CEVRNDCalculator" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (CEVRNDCalculator *)new CEVRNDCalculator(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CEVRNDCalculator > *smartresult = result ? new ext::shared_ptr<  CEVRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CEVRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CEVRNDCalculator_massAtZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CEVRNDCalculator *arg1 = (CEVRNDCalculator *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CEVRNDCalculator const > tempshared1 ;
  ext::shared_ptr< CEVRNDCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CEVRNDCalculator_massAtZero", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CEVRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CEVRNDCalculator_massAtZero" "', argument " "1"" of type '" "CEVRNDCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CEVRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CEVRNDCalculator > * >(argp1);
      arg1 = const_cast< CEVRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CEVRNDCalculator > * >(argp1);
      arg1 = const_cast< CEVRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CEVRNDCalculator_massAtZero" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((CEVRNDCalculator const *)arg1)->massAtZero(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CEVRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CEVRNDCalculator *arg1 = (CEVRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CEVRNDCalculator > tempshared1 ;
  ext::shared_ptr< CEVRNDCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CEVRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CEVRNDCalculator" "', argument " "1"" of type '" "CEVRNDCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CEVRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CEVRNDCalculator > * >(argp1);
      arg1 = const_cast< CEVRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CEVRNDCalculator > * >(argp1);
      arg1 = const_cast< CEVRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CEVRNDCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CEVRNDCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CEVRNDCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GBSMRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  GBSMRNDCalculator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSMRNDCalculator" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (GBSMRNDCalculator *)new GBSMRNDCalculator((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GBSMRNDCalculator > *smartresult = result ? new ext::shared_ptr<  GBSMRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GBSMRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GBSMRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GBSMRNDCalculator *arg1 = (GBSMRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GBSMRNDCalculator > tempshared1 ;
  ext::shared_ptr< GBSMRNDCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GBSMRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSMRNDCalculator" "', argument " "1"" of type '" "GBSMRNDCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GBSMRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GBSMRNDCalculator > * >(argp1);
      arg1 = const_cast< GBSMRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GBSMRNDCalculator > * >(argp1);
      arg1 = const_cast< GBSMRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GBSMRNDCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GBSMRNDCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GBSMRNDCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonRNDCalculator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Real arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  HestonRNDCalculator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonRNDCalculator" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HestonRNDCalculator" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HestonRNDCalculator" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (HestonRNDCalculator *)new HestonRNDCalculator((ext::shared_ptr< HestonProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonRNDCalculator > *smartresult = result ? new ext::shared_ptr<  HestonRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonRNDCalculator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  HestonRNDCalculator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonRNDCalculator" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HestonRNDCalculator" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (HestonRNDCalculator *)new HestonRNDCalculator((ext::shared_ptr< HestonProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonRNDCalculator > *smartresult = result ? new ext::shared_ptr<  HestonRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonRNDCalculator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  HestonRNDCalculator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonRNDCalculator" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (HestonRNDCalculator *)new HestonRNDCalculator((ext::shared_ptr< HestonProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonRNDCalculator > *smartresult = result ? new ext::shared_ptr<  HestonRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonRNDCalculator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonRNDCalculator", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HestonRNDCalculator__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HestonRNDCalculator__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_HestonRNDCalculator__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonRNDCalculator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonRNDCalculator::HestonRNDCalculator(ext::shared_ptr< HestonProcess > const &,Real,Size)\n"
    "    HestonRNDCalculator::HestonRNDCalculator(ext::shared_ptr< HestonProcess > const &,Real)\n"
    "    HestonRNDCalculator::HestonRNDCalculator(ext::shared_ptr< HestonProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HestonRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonRNDCalculator *arg1 = (HestonRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonRNDCalculator > tempshared1 ;
  ext::shared_ptr< HestonRNDCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonRNDCalculator" "', argument " "1"" of type '" "HestonRNDCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonRNDCalculator > * >(argp1);
      arg1 = const_cast< HestonRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonRNDCalculator > * >(argp1);
      arg1 = const_cast< HestonRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonRNDCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HestonRNDCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonRNDCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LocalVolRNDCalculator(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Quote > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg3 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg4 = 0 ;
  Size arg5 = (Size) 101 ;
  Size arg6 = (Size) 51 ;
  Real arg7 = (Real) 0.1 ;
  Real arg8 = (Real) 1e-6 ;
  Size arg9 = (Size) 10000 ;
  Time arg10 = (Time) -Null< Time >() ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Quote > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared3 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared4 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"spot",  (char *)"rTS",  (char *)"qTS",  (char *)"localVol",  (char *)"xGrid",  (char *)"tGrid",  (char *)"x0Density",  (char *)"localVolProbEps",  (char *)"maxIter",  (char *)"gaussianStepSize",  NULL 
  };
  LocalVolRNDCalculator *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOOOO:new_LocalVolRNDCalculator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_Quote_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalVolRNDCalculator" "', argument " "1"" of type '" "ext::shared_ptr< Quote > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Quote > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Quote > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Quote > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LocalVolRNDCalculator" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(obj2, &argp3, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalVolRNDCalculator" "', argument " "3"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp3) : &tempshared3;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LocalVolRNDCalculator" "', argument " "4"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp4) : &tempshared4;
    }
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_size_t(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LocalVolRNDCalculator" "', argument " "5"" of type '" "Size""'");
    } 
    arg5 = static_cast< Size >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_size_t(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LocalVolRNDCalculator" "', argument " "6"" of type '" "Size""'");
    } 
    arg6 = static_cast< Size >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_double(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LocalVolRNDCalculator" "', argument " "7"" of type '" "Real""'");
    } 
    arg7 = static_cast< Real >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LocalVolRNDCalculator" "', argument " "8"" of type '" "Real""'");
    } 
    arg8 = static_cast< Real >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_size_t(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_LocalVolRNDCalculator" "', argument " "9"" of type '" "Size""'");
    } 
    arg9 = static_cast< Size >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_double(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_LocalVolRNDCalculator" "', argument " "10"" of type '" "Time""'");
    } 
    arg10 = static_cast< Time >(val10);
  }
  {
    try {
      result = (LocalVolRNDCalculator *)new LocalVolRNDCalculator((ext::shared_ptr< Quote > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,(ext::shared_ptr< YieldTermStructure > const &)*arg3,(ext::shared_ptr< LocalVolTermStructure > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolRNDCalculator > *smartresult = result ? new ext::shared_ptr<  LocalVolRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolRNDCalculator_mesher(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LocalVolRNDCalculator *arg1 = (LocalVolRNDCalculator *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolRNDCalculator const > tempshared1 ;
  ext::shared_ptr< LocalVolRNDCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  ext::shared_ptr< Fdm1dMesher > result;
  
  if (!SWIG_Python_UnpackTuple(args, "LocalVolRNDCalculator_mesher", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolRNDCalculator_mesher" "', argument " "1"" of type '" "LocalVolRNDCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LocalVolRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LocalVolRNDCalculator > * >(argp1);
      arg1 = const_cast< LocalVolRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LocalVolRNDCalculator > * >(argp1);
      arg1 = const_cast< LocalVolRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalVolRNDCalculator_mesher" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = ((LocalVolRNDCalculator const *)arg1)->mesher(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Fdm1dMesher > *smartresult = result ? new ext::shared_ptr<  Fdm1dMesher >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Fdm1dMesher_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LocalVolRNDCalculator_rescaleTimeSteps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LocalVolRNDCalculator *arg1 = (LocalVolRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolRNDCalculator const > tempshared1 ;
  ext::shared_ptr< LocalVolRNDCalculator const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalVolRNDCalculator_rescaleTimeSteps" "', argument " "1"" of type '" "LocalVolRNDCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const LocalVolRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const LocalVolRNDCalculator > * >(argp1);
      arg1 = const_cast< LocalVolRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const LocalVolRNDCalculator > * >(argp1);
      arg1 = const_cast< LocalVolRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = LocalVolRNDCalculator_rescaleTimeSteps((LocalVolRNDCalculator const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LocalVolRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LocalVolRNDCalculator *arg1 = (LocalVolRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolRNDCalculator > tempshared1 ;
  ext::shared_ptr< LocalVolRNDCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalVolRNDCalculator" "', argument " "1"" of type '" "LocalVolRNDCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LocalVolRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LocalVolRNDCalculator > * >(argp1);
      arg1 = const_cast< LocalVolRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LocalVolRNDCalculator > * >(argp1);
      arg1 = const_cast< LocalVolRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocalVolRNDCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LocalVolRNDCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LocalVolRNDCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SquareRootProcessRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  SquareRootProcessRNDCalculator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SquareRootProcessRNDCalculator", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SquareRootProcessRNDCalculator" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SquareRootProcessRNDCalculator" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SquareRootProcessRNDCalculator" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SquareRootProcessRNDCalculator" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (SquareRootProcessRNDCalculator *)new SquareRootProcessRNDCalculator(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SquareRootProcessRNDCalculator > *smartresult = result ? new ext::shared_ptr<  SquareRootProcessRNDCalculator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SquareRootProcessRNDCalculator_stationary_pdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > tempshared1 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SquareRootProcessRNDCalculator_stationary_pdf", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SquareRootProcessRNDCalculator_stationary_pdf" "', argument " "1"" of type '" "SquareRootProcessRNDCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SquareRootProcessRNDCalculator_stationary_pdf" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((SquareRootProcessRNDCalculator const *)arg1)->stationary_pdf(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SquareRootProcessRNDCalculator_stationary_cdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > tempshared1 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SquareRootProcessRNDCalculator_stationary_cdf", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SquareRootProcessRNDCalculator_stationary_cdf" "', argument " "1"" of type '" "SquareRootProcessRNDCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SquareRootProcessRNDCalculator_stationary_cdf" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((SquareRootProcessRNDCalculator const *)arg1)->stationary_cdf(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SquareRootProcessRNDCalculator_stationary_invcdf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > tempshared1 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SquareRootProcessRNDCalculator_stationary_invcdf", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SquareRootProcessRNDCalculator_stationary_invcdf" "', argument " "1"" of type '" "SquareRootProcessRNDCalculator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SquareRootProcessRNDCalculator_stationary_invcdf" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((SquareRootProcessRNDCalculator const *)arg1)->stationary_invcdf(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SquareRootProcessRNDCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SquareRootProcessRNDCalculator *arg1 = (SquareRootProcessRNDCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator > tempshared1 ;
  ext::shared_ptr< SquareRootProcessRNDCalculator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SquareRootProcessRNDCalculator" "', argument " "1"" of type '" "SquareRootProcessRNDCalculator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SquareRootProcessRNDCalculator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SquareRootProcessRNDCalculator > * >(argp1);
      arg1 = const_cast< SquareRootProcessRNDCalculator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SquareRootProcessRNDCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SquareRootProcessRNDCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_FittingMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod > tempshared1 ;
  ext::shared_ptr< FittingMethod > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FittingMethod" "', argument " "1"" of type '" "FittingMethod *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared1 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_size" "', argument " "1"" of type '" "FittingMethod const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FittingMethod const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_solution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared1 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_solution" "', argument " "1"" of type '" "FittingMethod const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FittingMethod const *)arg1)->solution();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_numberOfIterations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared1 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_numberOfIterations" "', argument " "1"" of type '" "FittingMethod const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Integer)((FittingMethod const *)arg1)->numberOfIterations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_minimumCostValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared1 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_minimumCostValue" "', argument " "1"" of type '" "FittingMethod const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((FittingMethod const *)arg1)->minimumCostValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_constrainAtZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared1 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_constrainAtZero" "', argument " "1"" of type '" "FittingMethod const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((FittingMethod const *)arg1)->constrainAtZero();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FittingMethod_weights(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittingMethod *arg1 = (FittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared1 ;
  ext::shared_ptr< FittingMethod const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittingMethod_weights" "', argument " "1"" of type '" "FittingMethod const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp1);
      arg1 = const_cast< FittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((FittingMethod const *)arg1)->weights();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FittingMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  Array *arg8 = 0 ;
  Real arg9 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Array temp8 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      arg5 = const_cast< FittingMethod * >(tempshared5.get());
    } else {
      arg5 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5)->get());
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    if (ArrayFromSequence(swig_obj[7],&temp8)) {
      arg8 = &temp8;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FittedBondDiscountCurve" "', argument " "8"" of type '" "Array const &""'");
      }
      if (!argp8) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "8"" of type '" "Array const &""'"); 
      }
      arg8 = reinterpret_cast< Array * >(argp8);
    }
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FittedBondDiscountCurve" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6,arg7,(Array const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  Array *arg8 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Array temp8 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      arg5 = const_cast< FittingMethod * >(tempshared5.get());
    } else {
      arg5 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5)->get());
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    if (ArrayFromSequence(swig_obj[7],&temp8)) {
      arg8 = &temp8;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res8)) {
        SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_FittedBondDiscountCurve" "', argument " "8"" of type '" "Array const &""'");
      }
      if (!argp8) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "8"" of type '" "Array const &""'"); 
      }
      arg8 = reinterpret_cast< Array * >(argp8);
    }
  }
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6,arg7,(Array const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  Size arg7 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      arg5 = const_cast< FittingMethod * >(tempshared5.get());
    } else {
      arg5 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5)->get());
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  Real arg6 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared5 ;
  double val6 ;
  int ecode6 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      arg5 = const_cast< FittingMethod * >(tempshared5.get());
    } else {
      arg5 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5)->get());
    }
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  FittingMethod *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared5 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5);
      arg5 = const_cast< FittingMethod * >(tempshared5.get());
    } else {
      arg5 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp5)->get());
    }
  }
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve(arg1,(Calendar const &)*arg2,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg3,(DayCounter const &)*arg4,(FittingMethod const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Array *arg7 = 0 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared4 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Array temp7 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      arg4 = const_cast< FittingMethod * >(tempshared4.get());
    } else {
      arg4 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4)->get());
    }
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    if (ArrayFromSequence(swig_obj[6],&temp7)) {
      arg7 = &temp7;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Array const &""'");
      }
      if (!argp7) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Array const &""'"); 
      }
      arg7 = reinterpret_cast< Array * >(argp7);
    }
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FittedBondDiscountCurve" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5,arg6,(Array const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  Array *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared4 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Array temp7 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      arg4 = const_cast< FittingMethod * >(tempshared4.get());
    } else {
      arg4 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4)->get());
    }
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    if (ArrayFromSequence(swig_obj[6],&temp7)) {
      arg7 = &temp7;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res7)) {
        SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Array const &""'");
      }
      if (!argp7) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "7"" of type '" "Array const &""'"); 
      }
      arg7 = reinterpret_cast< Array * >(argp7);
    }
  }
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5,arg6,(Array const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  Size arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared4 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      arg4 = const_cast< FittingMethod * >(tempshared4.get());
    } else {
      arg4 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4)->get());
    }
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FittedBondDiscountCurve" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared4 ;
  double val5 ;
  int ecode5 = 0 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      arg4 = const_cast< FittingMethod * >(tempshared4.get());
    } else {
      arg4 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4)->get());
    }
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FittedBondDiscountCurve" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  FittingMethod *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< FittingMethod const > tempshared4 ;
  FittedBondDiscountCurve *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *ptr = (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FittedBondDiscountCurve" "', argument " "4"" of type '" "FittingMethod const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4);
      arg4 = const_cast< FittingMethod * >(tempshared4.get());
    } else {
      arg4 = const_cast< FittingMethod * >(reinterpret_cast< ext::shared_ptr< const FittingMethod > * >(argp4)->get());
    }
  }
  {
    try {
      result = (FittedBondDiscountCurve *)new FittedBondDiscountCurve((Date const &)*arg1,(std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &)*arg2,(DayCounter const &)*arg3,(FittingMethod const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FittedBondDiscountCurve > *smartresult = result ? new ext::shared_ptr<  FittedBondDiscountCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FittedBondDiscountCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FittedBondDiscountCurve", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FittedBondDiscountCurve__SWIG_9(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FittedBondDiscountCurve__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FittedBondDiscountCurve__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FittedBondDiscountCurve__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FittedBondDiscountCurve__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  /* native sequence? */
                  if (PyTuple_Check(argv[6]) || PyList_Check(argv[6])) {
                    Size size = PySequence_Size(argv[6]);
                    if (size == 0) {
                      _v = 1;
                    } else {
                      PyObject* o = PySequence_GetItem(argv[6],0);
                      if (PyNumber_Check(o))
                      _v = 1;
                      else
                      _v = 0;
                      Py_DECREF(o);
                    }
                  } else {
                    // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                }
                if (_v) {
                  return _wrap_new_FittedBondDiscountCurve__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FittedBondDiscountCurve__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  /* native sequence? */
                  if (PyTuple_Check(argv[6]) || PyList_Check(argv[6])) {
                    Size size = PySequence_Size(argv[6]);
                    if (size == 0) {
                      _v = 1;
                    } else {
                      PyObject* o = PySequence_GetItem(argv[6],0);
                      if (PyNumber_Check(o))
                      _v = 1;
                      else
                      _v = 0;
                      Py_DECREF(o);
                    }
                  } else {
                    // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_FittedBondDiscountCurve__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    /* native sequence? */
                    if (PyTuple_Check(argv[7]) || PyList_Check(argv[7])) {
                      Size size = PySequence_Size(argv[7]);
                      if (size == 0) {
                        _v = 1;
                      } else {
                        PyObject* o = PySequence_GetItem(argv[7],0);
                        if (PyNumber_Check(o))
                        _v = 1;
                        else
                        _v = 0;
                        Py_DECREF(o);
                      }
                    } else {
                      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                  }
                  if (_v) {
                    return _wrap_new_FittedBondDiscountCurve__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    /* native sequence? */
                    if (PyTuple_Check(argv[7]) || PyList_Check(argv[7])) {
                      Size size = PySequence_Size(argv[7]);
                      if (size == 0) {
                        _v = 1;
                      } else {
                        PyObject* o = PySequence_GetItem(argv[7],0);
                        if (PyNumber_Check(o))
                        _v = 1;
                        else
                        _v = 0;
                        Py_DECREF(o);
                      }
                    } else {
                      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_FittedBondDiscountCurve__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FittedBondDiscountCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Natural,Calendar const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real,Size,Array const &,Real)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Natural,Calendar const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real,Size,Array const &)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Natural,Calendar const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real,Size)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Natural,Calendar const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Natural,Calendar const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Date const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real,Size,Array const &,Real)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Date const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real,Size,Array const &)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Date const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real,Size)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Date const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &,Real)\n"
    "    FittedBondDiscountCurve::FittedBondDiscountCurve(Date const &,std::vector< ext::shared_ptr< BondHelper >,std::allocator< ext::shared_ptr< BondHelper > > > const &,DayCounter const &,FittingMethod const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FittedBondDiscountCurve_fitResults(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittedBondDiscountCurve *arg1 = (FittedBondDiscountCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittedBondDiscountCurve const > tempshared1 ;
  ext::shared_ptr< FittedBondDiscountCurve const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  FittingMethod *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FittedBondDiscountCurve_fitResults" "', argument " "1"" of type '" "FittedBondDiscountCurve const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const FittedBondDiscountCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const FittedBondDiscountCurve > * >(argp1);
      arg1 = const_cast< FittedBondDiscountCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const FittedBondDiscountCurve > * >(argp1);
      arg1 = const_cast< FittedBondDiscountCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (FittingMethod *) &((FittedBondDiscountCurve const *)arg1)->fitResults();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr< const FittingMethod > *smartresult = new ext::shared_ptr< const FittingMethod >(result SWIG_NO_NULL_DELETER_0);
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FittedBondDiscountCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FittedBondDiscountCurve *arg1 = (FittedBondDiscountCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FittedBondDiscountCurve > tempshared1 ;
  ext::shared_ptr< FittedBondDiscountCurve > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FittedBondDiscountCurve" "', argument " "1"" of type '" "FittedBondDiscountCurve *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FittedBondDiscountCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FittedBondDiscountCurve > * >(argp1);
      arg1 = const_cast< FittedBondDiscountCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FittedBondDiscountCurve > * >(argp1);
      arg1 = const_cast< FittedBondDiscountCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FittedBondDiscountCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FittedBondDiscountCurve_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FittedBondDiscountCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Size arg6 ;
  Real arg7 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialSplinesFitting" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExponentialSplinesFitting" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ExponentialSplinesFitting" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ExponentialSplinesFitting" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  Size arg6 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialSplinesFitting" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExponentialSplinesFitting" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ExponentialSplinesFitting" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialSplinesFitting" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ExponentialSplinesFitting" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Real arg4 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialSplinesFitting" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  Array *arg2 = 0 ;
  bool val1 ;
  int ecode1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialSplinesFitting" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1,(Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExponentialSplinesFitting" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ExponentialSplinesFitting *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ExponentialSplinesFitting *)new ExponentialSplinesFitting();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialSplinesFitting > *smartresult = result ? new ext::shared_ptr<  ExponentialSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialSplinesFitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExponentialSplinesFitting", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ExponentialSplinesFitting__SWIG_7(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ExponentialSplinesFitting__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_new_ExponentialSplinesFitting__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_new_ExponentialSplinesFitting__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ExponentialSplinesFitting__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ExponentialSplinesFitting__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ExponentialSplinesFitting__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ExponentialSplinesFitting__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExponentialSplinesFitting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool,Array const &,Array const &,Real,Real,Size,Real)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool,Array const &,Array const &,Real,Real,Size)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool,Array const &,Array const &,Real,Real)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool,Array const &,Array const &,Real)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool,Array const &,Array const &)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool,Array const &)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting(bool)\n"
    "    ExponentialSplinesFitting::ExponentialSplinesFitting()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExponentialSplinesFitting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExponentialSplinesFitting *arg1 = (ExponentialSplinesFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExponentialSplinesFitting > tempshared1 ;
  ext::shared_ptr< ExponentialSplinesFitting > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExponentialSplinesFitting" "', argument " "1"" of type '" "ExponentialSplinesFitting *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExponentialSplinesFitting > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExponentialSplinesFitting > * >(argp1);
      arg1 = const_cast< ExponentialSplinesFitting * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExponentialSplinesFitting > * >(argp1);
      arg1 = const_cast< ExponentialSplinesFitting * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExponentialSplinesFitting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExponentialSplinesFitting_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExponentialSplinesFitting_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NelsonSiegelFitting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  NelsonSiegelFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NelsonSiegelFitting" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NelsonSiegelFitting" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    try {
      result = (NelsonSiegelFitting *)new NelsonSiegelFitting((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NelsonSiegelFitting > *smartresult = result ? new ext::shared_ptr<  NelsonSiegelFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NelsonSiegelFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NelsonSiegelFitting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  NelsonSiegelFitting *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (NelsonSiegelFitting *)new NelsonSiegelFitting();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NelsonSiegelFitting > *smartresult = result ? new ext::shared_ptr<  NelsonSiegelFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NelsonSiegelFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NelsonSiegelFitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NelsonSiegelFitting", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_NelsonSiegelFitting__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      return _wrap_new_NelsonSiegelFitting__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NelsonSiegelFitting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NelsonSiegelFitting::NelsonSiegelFitting(Array const &)\n"
    "    NelsonSiegelFitting::NelsonSiegelFitting()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NelsonSiegelFitting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NelsonSiegelFitting *arg1 = (NelsonSiegelFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NelsonSiegelFitting > tempshared1 ;
  ext::shared_ptr< NelsonSiegelFitting > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NelsonSiegelFitting_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NelsonSiegelFitting" "', argument " "1"" of type '" "NelsonSiegelFitting *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NelsonSiegelFitting > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NelsonSiegelFitting > * >(argp1);
      arg1 = const_cast< NelsonSiegelFitting * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NelsonSiegelFitting > * >(argp1);
      arg1 = const_cast< NelsonSiegelFitting * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NelsonSiegelFitting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NelsonSiegelFitting_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NelsonSiegelFitting_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SvenssonFitting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SvenssonFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SvenssonFitting" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SvenssonFitting" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    try {
      result = (SvenssonFitting *)new SvenssonFitting((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SvenssonFitting > *smartresult = result ? new ext::shared_ptr<  SvenssonFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SvenssonFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SvenssonFitting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SvenssonFitting *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (SvenssonFitting *)new SvenssonFitting();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SvenssonFitting > *smartresult = result ? new ext::shared_ptr<  SvenssonFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SvenssonFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SvenssonFitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SvenssonFitting", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SvenssonFitting__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      return _wrap_new_SvenssonFitting__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SvenssonFitting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SvenssonFitting::SvenssonFitting(Array const &)\n"
    "    SvenssonFitting::SvenssonFitting()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SvenssonFitting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SvenssonFitting *arg1 = (SvenssonFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SvenssonFitting > tempshared1 ;
  ext::shared_ptr< SvenssonFitting > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SvenssonFitting_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SvenssonFitting" "', argument " "1"" of type '" "SvenssonFitting *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SvenssonFitting > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SvenssonFitting > * >(argp1);
      arg1 = const_cast< SvenssonFitting * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SvenssonFitting > * >(argp1);
      arg1 = const_cast< SvenssonFitting * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SvenssonFitting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SvenssonFitting_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SvenssonFitting_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CubicBSplinesFitting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  bool arg2 ;
  Array *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  CubicBSplinesFitting *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicBSplinesFitting" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicBSplinesFitting" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CubicBSplinesFitting" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicBSplinesFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicBSplinesFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = (CubicBSplinesFitting *)new CubicBSplinesFitting((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CubicBSplinesFitting > *smartresult = result ? new ext::shared_ptr<  CubicBSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicBSplinesFitting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  CubicBSplinesFitting *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicBSplinesFitting" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicBSplinesFitting" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CubicBSplinesFitting" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (CubicBSplinesFitting *)new CubicBSplinesFitting((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CubicBSplinesFitting > *smartresult = result ? new ext::shared_ptr<  CubicBSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicBSplinesFitting__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  CubicBSplinesFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicBSplinesFitting" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicBSplinesFitting" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (CubicBSplinesFitting *)new CubicBSplinesFitting((std::vector< Time,std::allocator< Time > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CubicBSplinesFitting > *smartresult = result ? new ext::shared_ptr<  CubicBSplinesFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicBSplinesFitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CubicBSplinesFitting", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CubicBSplinesFitting__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CubicBSplinesFitting__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_new_CubicBSplinesFitting__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CubicBSplinesFitting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CubicBSplinesFitting::CubicBSplinesFitting(std::vector< Time,std::allocator< Time > > const &,bool,Array const &)\n"
    "    CubicBSplinesFitting::CubicBSplinesFitting(std::vector< Time,std::allocator< Time > > const &,bool)\n"
    "    CubicBSplinesFitting::CubicBSplinesFitting(std::vector< Time,std::allocator< Time > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CubicBSplinesFitting_basisFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CubicBSplinesFitting *arg1 = (CubicBSplinesFitting *) 0 ;
  Integer arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CubicBSplinesFitting > tempshared1 ;
  ext::shared_ptr< CubicBSplinesFitting > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CubicBSplinesFitting_basisFunction", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicBSplinesFitting_basisFunction" "', argument " "1"" of type '" "CubicBSplinesFitting *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CubicBSplinesFitting > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CubicBSplinesFitting > * >(argp1);
      arg1 = const_cast< CubicBSplinesFitting * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CubicBSplinesFitting > * >(argp1);
      arg1 = const_cast< CubicBSplinesFitting * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicBSplinesFitting_basisFunction" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CubicBSplinesFitting_basisFunction" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(arg1)->basisFunction(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CubicBSplinesFitting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CubicBSplinesFitting *arg1 = (CubicBSplinesFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CubicBSplinesFitting > tempshared1 ;
  ext::shared_ptr< CubicBSplinesFitting > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CubicBSplinesFitting" "', argument " "1"" of type '" "CubicBSplinesFitting *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CubicBSplinesFitting > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CubicBSplinesFitting > * >(argp1);
      arg1 = const_cast< CubicBSplinesFitting * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CubicBSplinesFitting > * >(argp1);
      arg1 = const_cast< CubicBSplinesFitting * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CubicBSplinesFitting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CubicBSplinesFitting_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CubicBSplinesFitting_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SimplePolynomialFitting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  bool arg2 ;
  Array *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SimplePolynomialFitting *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SimplePolynomialFitting" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SimplePolynomialFitting" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SimplePolynomialFitting" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SimplePolynomialFitting" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = (SimplePolynomialFitting *)new SimplePolynomialFitting(arg1,arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SimplePolynomialFitting > *smartresult = result ? new ext::shared_ptr<  SimplePolynomialFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SimplePolynomialFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimplePolynomialFitting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  bool arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SimplePolynomialFitting *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SimplePolynomialFitting" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SimplePolynomialFitting" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (SimplePolynomialFitting *)new SimplePolynomialFitting(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SimplePolynomialFitting > *smartresult = result ? new ext::shared_ptr<  SimplePolynomialFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SimplePolynomialFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimplePolynomialFitting__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  SimplePolynomialFitting *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SimplePolynomialFitting" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  {
    try {
      result = (SimplePolynomialFitting *)new SimplePolynomialFitting(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SimplePolynomialFitting > *smartresult = result ? new ext::shared_ptr<  SimplePolynomialFitting >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SimplePolynomialFitting_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SimplePolynomialFitting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SimplePolynomialFitting", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SimplePolynomialFitting__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SimplePolynomialFitting__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          /* native sequence? */
          if (PyTuple_Check(argv[2]) || PyList_Check(argv[2])) {
            Size size = PySequence_Size(argv[2]);
            if (size == 0) {
              _v = 1;
            } else {
              PyObject* o = PySequence_GetItem(argv[2],0);
              if (PyNumber_Check(o))
              _v = 1;
              else
              _v = 0;
              Py_DECREF(o);
            }
          } else {
            // copied from SWIGTYPE typemap -- might need updating for newer SWIG
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
        }
        if (_v) {
          return _wrap_new_SimplePolynomialFitting__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SimplePolynomialFitting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SimplePolynomialFitting::SimplePolynomialFitting(Natural,bool,Array const &)\n"
    "    SimplePolynomialFitting::SimplePolynomialFitting(Natural,bool)\n"
    "    SimplePolynomialFitting::SimplePolynomialFitting(Natural)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SimplePolynomialFitting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimplePolynomialFitting *arg1 = (SimplePolynomialFitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SimplePolynomialFitting > tempshared1 ;
  ext::shared_ptr< SimplePolynomialFitting > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SimplePolynomialFitting_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimplePolynomialFitting" "', argument " "1"" of type '" "SimplePolynomialFitting *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SimplePolynomialFitting > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SimplePolynomialFitting > * >(argp1);
      arg1 = const_cast< SimplePolynomialFitting * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SimplePolynomialFitting > * >(argp1);
      arg1 = const_cast< SimplePolynomialFitting * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SimplePolynomialFitting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SimplePolynomialFitting_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SimplePolynomialFitting_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpreadFittingMethod__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FittingMethod > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SpreadFittingMethod *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadFittingMethod" "', argument " "1"" of type '" "ext::shared_ptr< FittingMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadFittingMethod" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadFittingMethod" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadFittingMethod" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpreadFittingMethod" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (SpreadFittingMethod *)new SpreadFittingMethod((ext::shared_ptr< FittingMethod > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadFittingMethod > *smartresult = result ? new ext::shared_ptr<  SpreadFittingMethod >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadFittingMethod_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadFittingMethod__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FittingMethod > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpreadFittingMethod *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadFittingMethod" "', argument " "1"" of type '" "ext::shared_ptr< FittingMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadFittingMethod" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadFittingMethod" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpreadFittingMethod" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (SpreadFittingMethod *)new SpreadFittingMethod((ext::shared_ptr< FittingMethod > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadFittingMethod > *smartresult = result ? new ext::shared_ptr<  SpreadFittingMethod >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadFittingMethod_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadFittingMethod__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FittingMethod > *arg1 = 0 ;
  Handle< YieldTermStructure > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FittingMethod > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  SpreadFittingMethod *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadFittingMethod" "', argument " "1"" of type '" "ext::shared_ptr< FittingMethod > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FittingMethod > * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadFittingMethod" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadFittingMethod" "', argument " "2"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (SpreadFittingMethod *)new SpreadFittingMethod((ext::shared_ptr< FittingMethod > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadFittingMethod > *smartresult = result ? new ext::shared_ptr<  SpreadFittingMethod >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadFittingMethod_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadFittingMethod(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SpreadFittingMethod", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpreadFittingMethod__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SpreadFittingMethod__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FittingMethod_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SpreadFittingMethod__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SpreadFittingMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SpreadFittingMethod::SpreadFittingMethod(ext::shared_ptr< FittingMethod > const &,Handle< YieldTermStructure >,Real,Real)\n"
    "    SpreadFittingMethod::SpreadFittingMethod(ext::shared_ptr< FittingMethod > const &,Handle< YieldTermStructure >,Real)\n"
    "    SpreadFittingMethod::SpreadFittingMethod(ext::shared_ptr< FittingMethod > const &,Handle< YieldTermStructure >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SpreadFittingMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SpreadFittingMethod *arg1 = (SpreadFittingMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SpreadFittingMethod > tempshared1 ;
  ext::shared_ptr< SpreadFittingMethod > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SpreadFittingMethod_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadFittingMethod" "', argument " "1"" of type '" "SpreadFittingMethod *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SpreadFittingMethod > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SpreadFittingMethod > * >(argp1);
      arg1 = const_cast< SpreadFittingMethod * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SpreadFittingMethod > * >(argp1);
      arg1 = const_cast< SpreadFittingMethod * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadFittingMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SpreadFittingMethod_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpreadFittingMethod_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  BackwardFlat *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedForwardCurve< BackwardFlat > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ForwardCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ForwardCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_BackwardFlat,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ForwardCurve" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "5"" of type '" "BackwardFlat const &""'"); 
  }
  arg5 = reinterpret_cast< BackwardFlat * >(argp5);
  {
    try {
      result = (InterpolatedForwardCurve< BackwardFlat > *)new InterpolatedForwardCurve< BackwardFlat >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(BackwardFlat const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedForwardCurve< BackwardFlat > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ForwardCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ForwardCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedForwardCurve< BackwardFlat > *)new InterpolatedForwardCurve< BackwardFlat >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedForwardCurve< BackwardFlat > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ForwardCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedForwardCurve< BackwardFlat > *)new InterpolatedForwardCurve< BackwardFlat >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > *smartresult = result ? new ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ForwardCurve", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ForwardCurve__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ForwardCurve__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_BackwardFlat, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ForwardCurve__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ForwardCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedForwardCurve< BackwardFlat >::InterpolatedForwardCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,BackwardFlat const &)\n"
    "    InterpolatedForwardCurve< BackwardFlat >::InterpolatedForwardCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedForwardCurve< BackwardFlat >::InterpolatedForwardCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ForwardCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > tempshared1 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardCurve_dates" "', argument " "1"" of type '" "InterpolatedForwardCurve< BackwardFlat > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedForwardCurve< BackwardFlat > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardCurve_forwards(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > tempshared1 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardCurve_forwards" "', argument " "1"" of type '" "InterpolatedForwardCurve< BackwardFlat > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedForwardCurve< BackwardFlat > const *)arg1)->forwards();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > tempshared1 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardCurve_nodes" "', argument " "1"" of type '" "InterpolatedForwardCurve< BackwardFlat > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedForwardCurve< BackwardFlat > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedForwardCurve< BackwardFlat > *arg1 = (InterpolatedForwardCurve< BackwardFlat > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > tempshared1 ;
  ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardCurve" "', argument " "1"" of type '" "InterpolatedForwardCurve< BackwardFlat > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedForwardCurve<BackwardFlat> > * >(argp1);
      arg1 = const_cast< InterpolatedForwardCurve< BackwardFlat > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Position *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Position", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Position *)new Position();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Position, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Position(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Position *arg1 = (Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Position, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', argument " "1"" of type '" "Position *""'"); 
  }
  arg1 = reinterpret_cast< Position * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Position_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Position, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Position_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ForwardRateAgreement" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ForwardRateAgreement" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ForwardRateAgreement" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  ext::shared_ptr< IborIndex > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< IborIndex > tempshared6 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp6) : &tempshared6;
    }
  }
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,(ext::shared_ptr< IborIndex > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Position::Type arg2 ;
  Rate arg3 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Position::Type""'");
  } 
  arg2 = static_cast< Position::Type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Position::Type arg2 ;
  Rate arg3 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< IborIndex > tempshared5 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Position::Type""'");
  } 
  arg2 = static_cast< Position::Type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((Date const &)*arg1,arg2,arg3,arg4,(ext::shared_ptr< IborIndex > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  Handle< YieldTermStructure > arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Position::Type arg3 ;
  Rate arg4 ;
  Real arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Position::Type""'");
  } 
  arg3 = static_cast< Position::Type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Rate""'");
  } 
  arg4 = static_cast< Rate >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(Date const &)*arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Position::Type arg4 ;
  Rate arg5 ;
  Real arg6 ;
  Handle< YieldTermStructure > arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Position::Type""'");
  } 
  arg4 = static_cast< Position::Type >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_ForwardRateAgreement" "', argument " "7"" of type '" "Handle< YieldTermStructure >""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "7"" of type '" "Handle< YieldTermStructure >""'");
    } else {
      Handle< YieldTermStructure > * temp = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< IborIndex > *arg1 = 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Position::Type arg4 ;
  Rate arg5 ;
  Real arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< IborIndex > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  ForwardRateAgreement *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForwardRateAgreement" "', argument " "1"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForwardRateAgreement" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ForwardRateAgreement" "', argument " "4"" of type '" "Position::Type""'");
  } 
  arg4 = static_cast< Position::Type >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ForwardRateAgreement" "', argument " "5"" of type '" "Rate""'");
  } 
  arg5 = static_cast< Rate >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ForwardRateAgreement" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  {
    try {
      result = (ForwardRateAgreement *)new ForwardRateAgreement((ext::shared_ptr< IborIndex > const &)*arg1,(Date const &)*arg2,(Date const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ForwardRateAgreement > *smartresult = result ? new ext::shared_ptr<  ForwardRateAgreement >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForwardRateAgreement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ForwardRateAgreement", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ForwardRateAgreement__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ForwardRateAgreement__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_ForwardRateAgreement__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ForwardRateAgreement__SWIG_8(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_ForwardRateAgreement__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_ForwardRateAgreement__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ForwardRateAgreement__SWIG_7(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_ForwardRateAgreement__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ForwardRateAgreement__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ForwardRateAgreement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ForwardRateAgreement::ForwardRateAgreement(Date const &,Date const &,Position::Type,Rate,Real,ext::shared_ptr< IborIndex > const &,Handle< YieldTermStructure > const &,bool)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(Date const &,Date const &,Position::Type,Rate,Real,ext::shared_ptr< IborIndex > const &,Handle< YieldTermStructure > const &)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(Date const &,Date const &,Position::Type,Rate,Real,ext::shared_ptr< IborIndex > const &)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(Date const &,Position::Type,Rate,Real,ext::shared_ptr< IborIndex > const &,Handle< YieldTermStructure > const &)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(Date const &,Position::Type,Rate,Real,ext::shared_ptr< IborIndex > const &)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(ext::shared_ptr< IborIndex > const &,Date const &,Position::Type,Rate,Real,Handle< YieldTermStructure >)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(ext::shared_ptr< IborIndex > const &,Date const &,Position::Type,Rate,Real)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(ext::shared_ptr< IborIndex > const &,Date const &,Date const &,Position::Type,Rate,Real,Handle< YieldTermStructure >)\n"
    "    ForwardRateAgreement::ForwardRateAgreement(ext::shared_ptr< IborIndex > const &,Date const &,Date const &,Position::Type,Rate,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ForwardRateAgreement_amount(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardRateAgreement const > tempshared1 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardRateAgreement_amount" "', argument " "1"" of type '" "ForwardRateAgreement const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((ForwardRateAgreement const *)arg1)->amount();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardRateAgreement_fixingDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardRateAgreement const > tempshared1 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardRateAgreement_fixingDate" "', argument " "1"" of type '" "ForwardRateAgreement const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ForwardRateAgreement const *)arg1)->fixingDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ForwardRateAgreement_forwardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardRateAgreement const > tempshared1 ;
  ext::shared_ptr< ForwardRateAgreement const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  InterestRate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardRateAgreement_forwardRate" "', argument " "1"" of type '" "ForwardRateAgreement const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((ForwardRateAgreement const *)arg1)->forwardRate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new InterestRate(result)), SWIGTYPE_p_InterestRate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ForwardRateAgreement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ForwardRateAgreement *arg1 = (ForwardRateAgreement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ForwardRateAgreement > tempshared1 ;
  ext::shared_ptr< ForwardRateAgreement > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForwardRateAgreement" "', argument " "1"" of type '" "ForwardRateAgreement *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ForwardRateAgreement > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ForwardRateAgreement > * >(argp1);
      arg1 = const_cast< ForwardRateAgreement * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForwardRateAgreement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ForwardRateAgreement_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ForwardRateAgreement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Gaussian1dModel_stateProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< StochasticProcess1D > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_stateProcess" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Gaussian1dModel const *)arg1)->stateProcess();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StochasticProcess1D > *smartresult = result ? new ext::shared_ptr<  StochasticProcess1D >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StochasticProcess1D_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_numeraire" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_numeraire" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_numeraire" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_numeraire" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->numeraire(arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_numeraire" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_numeraire" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->numeraire(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_numeraire" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->numeraire(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gaussian1dModel_zerobond" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobond" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  {
    try {
      result = (Real)(arg1)->zerobond(arg2,arg3,arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gaussian1dModel_zerobond" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)(arg1)->zerobond(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)(arg1)->zerobond(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)(arg1)->zerobond(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  Handle< YieldTermStructure > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_numeraire" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_numeraire" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_numeraire" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_numeraire" "', argument " "4"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< YieldTermStructure > * >(argp4);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->numeraire((Date const &)*arg2,arg3,(Handle< YieldTermStructure > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_numeraire" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gaussian1dModel_numeraire" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->numeraire((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_numeraire" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_numeraire" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->numeraire((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_numeraire(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gaussian1dModel_numeraire", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Gaussian1dModel_numeraire__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Gaussian1dModel_numeraire__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Gaussian1dModel_numeraire__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Gaussian1dModel_numeraire__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Gaussian1dModel_numeraire__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Gaussian1dModel_numeraire__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gaussian1dModel_numeraire'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dModel::numeraire(Time const,Real const,Handle< YieldTermStructure > const &) const\n"
    "    Gaussian1dModel::numeraire(Time const,Real const) const\n"
    "    Gaussian1dModel::numeraire(Time const) const\n"
    "    Gaussian1dModel::numeraire(Date const &,Real const,Handle< YieldTermStructure > const &) const\n"
    "    Gaussian1dModel::numeraire(Date const &,Real const) const\n"
    "    Gaussian1dModel::numeraire(Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  Handle< YieldTermStructure > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gaussian1dModel_zerobond" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobond" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "5"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< YieldTermStructure > * >(argp5);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobond((Date const &)*arg2,(Date const &)*arg3,arg4,(Handle< YieldTermStructure > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gaussian1dModel_zerobond" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobond((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobond((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobond" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobond" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobond((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gaussian1dModel_zerobond", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Gaussian1dModel_zerobond__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Gaussian1dModel_zerobond__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Gaussian1dModel_zerobond__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Gaussian1dModel_zerobond__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Gaussian1dModel_zerobond__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Gaussian1dModel_zerobond__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Gaussian1dModel_zerobond__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Gaussian1dModel_zerobond__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gaussian1dModel_zerobond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dModel::zerobond(Time const,Time const,Real const,Handle< YieldTermStructure > const &)\n"
    "    Gaussian1dModel::zerobond(Time const,Time const,Real const)\n"
    "    Gaussian1dModel::zerobond(Time const,Time const)\n"
    "    Gaussian1dModel::zerobond(Time const)\n"
    "    Gaussian1dModel::zerobond(Date const &,Date const &,Real const,Handle< YieldTermStructure > const &) const\n"
    "    Gaussian1dModel::zerobond(Date const &,Date const &,Real const) const\n"
    "    Gaussian1dModel::zerobond(Date const &,Date const &) const\n"
    "    Gaussian1dModel::zerobond(Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Size arg11 ;
  bool arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  Real result;
  
  if ((nobjs < 13) || (nobjs > 13)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "11"" of type '" "Size""'");
  } 
  arg11 = static_cast< Size >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10,arg11,arg12,arg13);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Size arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  Real result;
  
  if ((nobjs < 12) || (nobjs > 12)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "11"" of type '" "Size""'");
  } 
  arg11 = static_cast< Size >(val11);
  ecode12 = SWIG_AsVal_bool(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10,arg11,arg12);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  Size arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  Real result;
  
  if ((nobjs < 11) || (nobjs > 11)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "11"" of type '" "Size""'");
  } 
  arg11 = static_cast< Size >(val11);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10,arg11);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Real result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  Handle< YieldTermStructure > *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  Real result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "9"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg9 = reinterpret_cast< Handle< YieldTermStructure > * >(argp9);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8,(Handle< YieldTermStructure > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Real result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  Date *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Real result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "7"" of type '" "Date const &""'"); 
  }
  arg7 = reinterpret_cast< Date * >(argp7);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6,(Date const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Option::Type *arg2 = 0 ;
  Date *arg3 = 0 ;
  Date *arg4 = 0 ;
  Date *arg5 = 0 ;
  Rate arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 ;
  Option::Type temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int (swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "2"" of type '" "Option::Type const &""'");
  } else {
    temp2 = static_cast< Option::Type >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_zerobondOption" "', argument " "5"" of type '" "Date const &""'"); 
  }
  arg5 = reinterpret_cast< Date * >(argp5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gaussian1dModel_zerobondOption" "', argument " "6"" of type '" "Rate""'");
  } 
  arg6 = static_cast< Rate >(val6);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->zerobondOption((Option::Type const &)*arg2,(Date const &)*arg3,(Date const &)*arg4,(Date const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_zerobondOption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[14] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gaussian1dModel_zerobondOption", 0, 13, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Gaussian1dModel_zerobondOption__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Gaussian1dModel_zerobondOption__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Gaussian1dModel_zerobondOption__SWIG_5(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Gaussian1dModel_zerobondOption__SWIG_4(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Gaussian1dModel_zerobondOption__SWIG_3(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_size_t(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Gaussian1dModel_zerobondOption__SWIG_2(self, argc, argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_size_t(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Gaussian1dModel_zerobondOption__SWIG_1(self, argc, argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_size_t(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Gaussian1dModel_zerobondOption__SWIG_0(self, argc, argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gaussian1dModel_zerobondOption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &,Real const,Handle< YieldTermStructure > const &,Real const,Size const,bool const,bool const) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &,Real const,Handle< YieldTermStructure > const &,Real const,Size const,bool const) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &,Real const,Handle< YieldTermStructure > const &,Real const,Size const) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &,Real const,Handle< YieldTermStructure > const &,Real const) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &,Real const,Handle< YieldTermStructure > const &) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &,Real const) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const,Date const &) const\n"
    "    Gaussian1dModel::zerobondOption(Option::Type const &,Date const &,Date const &,Date const &,Rate const) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_forwardRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  ext::shared_ptr< IborIndex > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_forwardRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gaussian1dModel_forwardRate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gaussian1dModel_forwardRate" "', argument " "5"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp5);
  }
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_forwardRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_forwardRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gaussian1dModel_forwardRate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_forwardRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Date *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_forwardRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->forwardRate((Date const &)*arg2,(Date const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_forwardRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Real result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_forwardRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_forwardRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->forwardRate((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_forwardRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gaussian1dModel_forwardRate", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Gaussian1dModel_forwardRate__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Gaussian1dModel_forwardRate__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Gaussian1dModel_forwardRate__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Gaussian1dModel_forwardRate__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gaussian1dModel_forwardRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dModel::forwardRate(Date const &,Date const &,Real const,ext::shared_ptr< IborIndex >) const\n"
    "    Gaussian1dModel::forwardRate(Date const &,Date const &,Real const) const\n"
    "    Gaussian1dModel::forwardRate(Date const &,Date const &) const\n"
    "    Gaussian1dModel::forwardRate(Date const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapRate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< SwapIndex > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 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 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_swapRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gaussian1dModel_swapRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Gaussian1dModel_swapRate" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
  }
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapRate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_swapRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gaussian1dModel_swapRate" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapRate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_swapRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapRate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapRate" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapRate" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapRate((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapRate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gaussian1dModel_swapRate", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Gaussian1dModel_swapRate__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Gaussian1dModel_swapRate__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Gaussian1dModel_swapRate__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Gaussian1dModel_swapRate__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gaussian1dModel_swapRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dModel::swapRate(Date const &,Period const &,Date const &,Real const,ext::shared_ptr< SwapIndex >) const\n"
    "    Gaussian1dModel::swapRate(Date const &,Period const &,Date const &,Real const) const\n"
    "    Gaussian1dModel::swapRate(Date const &,Period const &,Date const &) const\n"
    "    Gaussian1dModel::swapRate(Date const &,Period const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapAnnuity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  ext::shared_ptr< SwapIndex > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 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 ;
  int res6 = 0 ;
  Real result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "6"" of type '" "ext::shared_ptr< SwapIndex >""'");
    }
    if (argp6) arg6 = *(reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp6);
  }
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapAnnuity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapAnnuity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapAnnuity__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  Date *arg2 = 0 ;
  Period *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel const > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Real result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "1"" of type '" "Gaussian1dModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gaussian1dModel_swapAnnuity" "', argument " "3"" of type '" "Period const &""'"); 
  }
  arg3 = reinterpret_cast< Period * >(argp3);
  {
    try {
      result = (Real)((Gaussian1dModel const *)arg1)->swapAnnuity((Date const &)*arg2,(Period const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gaussian1dModel_swapAnnuity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gaussian1dModel_swapAnnuity", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Gaussian1dModel_swapAnnuity__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Gaussian1dModel_swapAnnuity__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Gaussian1dModel_swapAnnuity__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Gaussian1dModel_swapAnnuity__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gaussian1dModel_swapAnnuity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dModel::swapAnnuity(Date const &,Period const &,Date const &,Real const,ext::shared_ptr< SwapIndex >) const\n"
    "    Gaussian1dModel::swapAnnuity(Date const &,Period const &,Date const &,Real const) const\n"
    "    Gaussian1dModel::swapAnnuity(Date const &,Period const &,Date const &) const\n"
    "    Gaussian1dModel::swapAnnuity(Date const &,Period const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Gaussian1dModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dModel *arg1 = (Gaussian1dModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  ext::shared_ptr< Gaussian1dModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gaussian1dModel" "', argument " "1"" of type '" "Gaussian1dModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dModel > * >(argp1);
      arg1 = const_cast< Gaussian1dModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gaussian1dModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Gsr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  double val5 ;
  int ecode5 = 0 ;
  Gsr *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gsr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Gsr" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Gsr" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Gsr" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gsr" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Gsr *)new Gsr((Handle< YieldTermStructure > const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gsr > *smartresult = result ? new ext::shared_ptr<  Gsr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gsr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gsr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg3 = 0 ;
  std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Gsr *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gsr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Gsr" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Gsr" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "3"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *ptr = (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Gsr" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gsr" "', argument " "4"" of type '" "std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = (Gsr *)new Gsr((Handle< YieldTermStructure > const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg3,(std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gsr > *smartresult = result ? new ext::shared_ptr<  Gsr >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gsr_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gsr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Gsr", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Gsr__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Gsr__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Gsr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gsr::Gsr(Handle< YieldTermStructure > const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,Real const)\n"
    "    Gsr::Gsr(Handle< YieldTermStructure > const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &,std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrateVolatilitiesIterative__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (arg1)->calibrateVolatilitiesIterative((std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrateVolatilitiesIterative__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (arg1)->calibrateVolatilitiesIterative((std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrateVolatilitiesIterative__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrateVolatilitiesIterative" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (arg1)->calibrateVolatilitiesIterative((std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrateVolatilitiesIterative(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gsr_calibrateVolatilitiesIterative", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Gsr_calibrateVolatilitiesIterative__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Gsr_calibrateVolatilitiesIterative__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Gsr_calibrateVolatilitiesIterative__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gsr_calibrateVolatilitiesIterative'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gsr::calibrateVolatilitiesIterative(std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    Gsr::calibrateVolatilitiesIterative(std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    Gsr::calibrateVolatilitiesIterative(std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gsr_reversion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_reversion" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &((Gsr const *)arg1)->reversion();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_volatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_volatility" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &((Gsr const *)arg1)->volatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_params" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((Gsr const *)arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrate" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gsr_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Gsr_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Gsr_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(std::vector< bool,std::allocator< bool > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrate" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gsr_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Gsr_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrate" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Gsr_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_calibrate" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_calibrate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Gsr_calibrate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Gsr_calibrate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Gsr_calibrate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Gsr_calibrate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector<bool,std::allocator< bool > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Gsr_calibrate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Gsr_calibrate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gsr::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &,std::vector< bool,std::allocator< bool > > const &)\n"
    "    Gsr::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    Gsr::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    Gsr::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Gsr_setParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "Gsr_setParams", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_setParams" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_setParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_setParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Gsr_value", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_value" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gsr_value" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_value" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Gsr_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gsr_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Real)(arg1)->value((Array const &)*arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_constraint" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &((Gsr const *)arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Constraint > *smartresult = *result ? new ext::shared_ptr<  Constraint >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_endCriteria" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((Gsr const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_problemValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_problemValues" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &((Gsr const *)arg1)->problemValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Gsr_functionEvaluation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr const > tempshared1 ;
  ext::shared_ptr< Gsr const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gsr_functionEvaluation" "', argument " "1"" of type '" "Gsr const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Integer)((Gsr const *)arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Gsr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gsr *arg1 = (Gsr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gsr > tempshared1 ;
  ext::shared_ptr< Gsr > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gsr_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gsr" "', argument " "1"" of type '" "Gsr *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gsr > * >(argp1);
      arg1 = const_cast< Gsr * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gsr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gsr_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Gsr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MarkovFunctional__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg7 = 0 ;
  ext::shared_ptr< SwapIndex > *arg8 = 0 ;
  MarkovFunctional::ModelSettings *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared8 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  MarkovFunctional *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovFunctional" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MarkovFunctional" "', argument " "7"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "7"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_MarkovFunctional" "', argument " "8"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp8) : &tempshared8;
    }
  }
  res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_MarkovFunctional__ModelSettings,  0  | 0);
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_MarkovFunctional" "', argument " "9"" of type '" "MarkovFunctional::ModelSettings const &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "9"" of type '" "MarkovFunctional::ModelSettings const &""'"); 
  }
  arg9 = reinterpret_cast< MarkovFunctional::ModelSettings * >(argp9);
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(std::vector< Period,std::allocator< Period > > const &)*arg7,(ext::shared_ptr< SwapIndex > const &)*arg8,(MarkovFunctional::ModelSettings const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MarkovFunctional > *smartresult = result ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctional__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  std::vector< Period,std::allocator< Period > > *arg7 = 0 ;
  ext::shared_ptr< SwapIndex > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 ;
  int res8 = 0 ;
  ext::shared_ptr< SwapIndex > tempshared8 ;
  MarkovFunctional *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovFunctional" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MarkovFunctional" "', argument " "7"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "7"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    int newmem = 0;
    res8 = SWIG_ConvertPtrAndOwn(swig_obj[7], &argp8, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_MarkovFunctional" "', argument " "8"" of type '" "ext::shared_ptr< SwapIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp8) tempshared8 = *reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp8);
      delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp8);
      arg8 = &tempshared8;
    } else {
      arg8 = (argp8) ? reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp8) : &tempshared8;
    }
  }
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,(Handle< SwaptionVolatilityStructure > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(std::vector< Period,std::allocator< Period > > const &)*arg7,(ext::shared_ptr< SwapIndex > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MarkovFunctional > *smartresult = result ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctional__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Handle< OptionletVolatilityStructure > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  MarkovFunctional::ModelSettings *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  MarkovFunctional *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovFunctional" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MarkovFunctional" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_MarkovFunctional__ModelSettings,  0  | 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_MarkovFunctional" "', argument " "8"" of type '" "MarkovFunctional::ModelSettings const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "8"" of type '" "MarkovFunctional::ModelSettings const &""'"); 
  }
  arg8 = reinterpret_cast< MarkovFunctional::ModelSettings * >(argp8);
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,(Handle< OptionletVolatilityStructure > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7,(MarkovFunctional::ModelSettings const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MarkovFunctional > *smartresult = result ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctional__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Real arg2 ;
  std::vector< Date,std::allocator< Date > > *arg3 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg4 = 0 ;
  Handle< OptionletVolatilityStructure > *arg5 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  ext::shared_ptr< IborIndex > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 ;
  int res7 = 0 ;
  ext::shared_ptr< IborIndex > tempshared7 ;
  MarkovFunctional *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovFunctional" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "3"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "4"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "5"" of type '" "Handle< OptionletVolatilityStructure > const &""'"); 
  }
  arg5 = reinterpret_cast< Handle< OptionletVolatilityStructure > * >(argp5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctional" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    int newmem = 0;
    res7 = SWIG_ConvertPtrAndOwn(swig_obj[6], &argp7, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_MarkovFunctional" "', argument " "7"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp7) tempshared7 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7);
      arg7 = &tempshared7;
    } else {
      arg7 = (argp7) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp7) : &tempshared7;
    }
  }
  {
    try {
      result = (MarkovFunctional *)new MarkovFunctional((Handle< YieldTermStructure > const &)*arg1,arg2,(std::vector< Date,std::allocator< Date > > const &)*arg3,(std::vector< Real,std::allocator< Real > > const &)*arg4,(Handle< OptionletVolatilityStructure > const &)*arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,(ext::shared_ptr< IborIndex > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MarkovFunctional > *smartresult = result ? new ext::shared_ptr<  MarkovFunctional >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctional(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MarkovFunctional", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_MarkovFunctional__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_OptionletVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_POINTER_NO_NULL | 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_MarkovFunctional__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< Period,std::allocator< Period > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_MarkovFunctional__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Date,std::allocator< Date > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< Period,std::allocator< Period > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_ConvertPtr(argv[7], 0, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_POINTER_NO_NULL | 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_MarkovFunctional__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MarkovFunctional'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MarkovFunctional::MarkovFunctional(Handle< YieldTermStructure > const &,Real const,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Handle< SwaptionVolatilityStructure > const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,ext::shared_ptr< SwapIndex > const &,MarkovFunctional::ModelSettings const &)\n"
    "    MarkovFunctional::MarkovFunctional(Handle< YieldTermStructure > const &,Real const,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Handle< SwaptionVolatilityStructure > const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Period,std::allocator< Period > > const &,ext::shared_ptr< SwapIndex > const &)\n"
    "    MarkovFunctional::MarkovFunctional(Handle< YieldTermStructure > const &,Real const,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Handle< OptionletVolatilityStructure > const &,std::vector< Date,std::allocator< Date > > const &,ext::shared_ptr< IborIndex > const &,MarkovFunctional::ModelSettings const &)\n"
    "    MarkovFunctional::MarkovFunctional(Handle< YieldTermStructure > const &,Real const,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Handle< OptionletVolatilityStructure > const &,std::vector< Date,std::allocator< Date > > const &,ext::shared_ptr< IborIndex > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_volatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_volatility" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &(arg1)->volatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_calibrate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  std::vector< bool,std::allocator< bool > > *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_calibrate" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkovFunctional_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MarkovFunctional_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res7 = swig::asptr(swig_obj[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MarkovFunctional_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "7"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg7 = ptr;
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6,(std::vector< bool,std::allocator< bool > > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_calibrate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_calibrate" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkovFunctional_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MarkovFunctional_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "6"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5,(std::vector< Real,std::allocator< Real > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_calibrate__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  Constraint *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ext::shared_ptr< Constraint const > tempshared5 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_calibrate" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Constraint_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MarkovFunctional_calibrate" "', argument " "5"" of type '" "Constraint const &""'");
    }
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "5"" of type '" "Constraint const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared5 = *reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5);
      arg5 = const_cast< Constraint * >(tempshared5.get());
    } else {
      arg5 = const_cast< Constraint * >(reinterpret_cast< ext::shared_ptr< const Constraint > * >(argp5)->get());
    }
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4,(Constraint const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_calibrate__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg2 = 0 ;
  OptimizationMethod *arg3 = 0 ;
  EndCriteria *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ext::shared_ptr< OptimizationMethod > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ext::shared_ptr< EndCriteria const > tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_calibrate" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "2"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'");
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "3"" of type '" "OptimizationMethod &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared3 = *reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3);
      arg3 = const_cast< OptimizationMethod * >(tempshared3.get());
    } else {
      arg3 = const_cast< OptimizationMethod * >(reinterpret_cast< ext::shared_ptr<  OptimizationMethod > * >(argp3)->get());
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'");
    }
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_calibrate" "', argument " "4"" of type '" "EndCriteria const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared4 = *reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4);
      arg4 = const_cast< EndCriteria * >(tempshared4.get());
    } else {
      arg4 = const_cast< EndCriteria * >(reinterpret_cast< ext::shared_ptr< const EndCriteria > * >(argp4)->get());
    }
  }
  {
    try {
      (arg1)->calibrate((std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg2,*arg3,(EndCriteria const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_calibrate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MarkovFunctional_calibrate", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MarkovFunctional_calibrate__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_MarkovFunctional_calibrate__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_MarkovFunctional_calibrate__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_OptimizationMethod_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_ext__shared_ptrT_EndCriteria_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_ext__shared_ptrT_Constraint_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< double,std::allocator< double > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector<bool,std::allocator< bool > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_MarkovFunctional_calibrate__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MarkovFunctional_calibrate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MarkovFunctional::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &,std::vector< bool,std::allocator< bool > > const &)\n"
    "    MarkovFunctional::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &,std::vector< Real,std::allocator< Real > > const &)\n"
    "    MarkovFunctional::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &,Constraint const &)\n"
    "    MarkovFunctional::calibrate(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &,OptimizationMethod &,EndCriteria const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional const > tempshared1 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_params" "', argument " "1"" of type '" "MarkovFunctional const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((MarkovFunctional const *)arg1)->params();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_setParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarkovFunctional_setParams", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_setParams" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovFunctional_setParams" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_setParams" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->setParams((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  Array *arg2 = 0 ;
  std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "MarkovFunctional_value", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_value" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarkovFunctional_value" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_value" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *ptr = (std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MarkovFunctional_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarkovFunctional_value" "', argument " "3"" of type '" "std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (Real)(arg1)->value((Array const &)*arg2,(std::vector< ext::shared_ptr< CalibrationHelper >,std::allocator< ext::shared_ptr< CalibrationHelper > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_constraint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional const > tempshared1 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Constraint > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_constraint" "', argument " "1"" of type '" "MarkovFunctional const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< Constraint > *) &((MarkovFunctional const *)arg1)->constraint();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Constraint > *smartresult = *result ? new ext::shared_ptr<  Constraint >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Constraint_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_endCriteria(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional const > tempshared1 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EndCriteria::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_endCriteria" "', argument " "1"" of type '" "MarkovFunctional const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EndCriteria::Type)((MarkovFunctional const *)arg1)->endCriteria();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_problemValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional const > tempshared1 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_problemValues" "', argument " "1"" of type '" "MarkovFunctional const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Array *) &((MarkovFunctional const *)arg1)->problemValues();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarkovFunctional_functionEvaluation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional const > tempshared1 ;
  ext::shared_ptr< MarkovFunctional const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Integer result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctional_functionEvaluation" "', argument " "1"" of type '" "MarkovFunctional const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Integer)((MarkovFunctional const *)arg1)->functionEvaluation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MarkovFunctional(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional *arg1 = (MarkovFunctional *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarkovFunctional > tempshared1 ;
  ext::shared_ptr< MarkovFunctional > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkovFunctional" "', argument " "1"" of type '" "MarkovFunctional *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarkovFunctional > * >(argp1);
      arg1 = const_cast< MarkovFunctional * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarkovFunctional_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MarkovFunctional_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MarkovFunctional_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MarkovFunctionalSettings__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  MarkovFunctional::ModelSettings *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (MarkovFunctional::ModelSettings *)new MarkovFunctional::ModelSettings();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctionalSettings__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Size arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  int arg8 ;
  std::vector< Real,std::allocator< Real > > *arg9 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  MarkovFunctional::ModelSettings *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkovFunctionalSettings" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovFunctionalSettings" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MarkovFunctionalSettings" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MarkovFunctionalSettings" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MarkovFunctionalSettings" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MarkovFunctionalSettings" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MarkovFunctionalSettings" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MarkovFunctionalSettings" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_MarkovFunctionalSettings" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarkovFunctionalSettings" "', argument " "9"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    try {
      result = (MarkovFunctional::ModelSettings *)new MarkovFunctional::ModelSettings(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::vector< Real,std::allocator< Real > > const &)*arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res9)) delete arg9;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res9)) delete arg9;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctionalSettings__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Size arg3 ;
  Real arg4 ;
  Real arg5 ;
  Real arg6 ;
  Real arg7 ;
  int arg8 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  MarkovFunctional::ModelSettings *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MarkovFunctionalSettings" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MarkovFunctionalSettings" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MarkovFunctionalSettings" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MarkovFunctionalSettings" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MarkovFunctionalSettings" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MarkovFunctionalSettings" "', argument " "6"" of type '" "Real""'");
  } 
  arg6 = static_cast< Real >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MarkovFunctionalSettings" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_MarkovFunctionalSettings" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    try {
      result = (MarkovFunctional::ModelSettings *)new MarkovFunctional::ModelSettings(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarkovFunctionalSettings(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MarkovFunctionalSettings", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MarkovFunctionalSettings__SWIG_0(self, argc, argv);
  }
  if (argc == 8) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_MarkovFunctionalSettings__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = swig::asptr(argv[8], (std::vector< double,std::allocator< double > >**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_MarkovFunctionalSettings__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MarkovFunctionalSettings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MarkovFunctional::ModelSettings::ModelSettings()\n"
    "    MarkovFunctional::ModelSettings::ModelSettings(Size,Real,Size,Real,Real,Real,Real,int,std::vector< Real,std::allocator< Real > > const &)\n"
    "    MarkovFunctional::ModelSettings::ModelSettings(Size,Real,Size,Real,Real,Real,Real,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MarkovFunctionalSettings_validate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional::ModelSettings *arg1 = (MarkovFunctional::ModelSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkovFunctional__ModelSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarkovFunctionalSettings_validate" "', argument " "1"" of type '" "MarkovFunctional::ModelSettings *""'"); 
  }
  arg1 = reinterpret_cast< MarkovFunctional::ModelSettings * >(argp1);
  {
    try {
      (arg1)->validate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MarkovFunctionalSettings(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarkovFunctional::ModelSettings *arg1 = (MarkovFunctional::ModelSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarkovFunctionalSettings" "', argument " "1"" of type '" "MarkovFunctional::ModelSettings *""'"); 
  }
  arg1 = reinterpret_cast< MarkovFunctional::ModelSettings * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarkovFunctionalSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MarkovFunctional__ModelSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MarkovFunctionalSettings_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  Gaussian1dCapFloorEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Gaussian1dCapFloorEngine *)new Gaussian1dCapFloorEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dCapFloorEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dCapFloorEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dCapFloorEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Gaussian1dCapFloorEngine", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Gaussian1dCapFloorEngine__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Gaussian1dCapFloorEngine__SWIG_4(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Gaussian1dCapFloorEngine__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Gaussian1dCapFloorEngine__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Gaussian1dCapFloorEngine__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Gaussian1dCapFloorEngine__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Gaussian1dCapFloorEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dCapFloorEngine::Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< YieldTermStructure > const &)\n"
    "    Gaussian1dCapFloorEngine::Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const)\n"
    "    Gaussian1dCapFloorEngine::Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const)\n"
    "    Gaussian1dCapFloorEngine::Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const)\n"
    "    Gaussian1dCapFloorEngine::Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const &,int const)\n"
    "    Gaussian1dCapFloorEngine::Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Gaussian1dCapFloorEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dCapFloorEngine *arg1 = (Gaussian1dCapFloorEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dCapFloorEngine > tempshared1 ;
  ext::shared_ptr< Gaussian1dCapFloorEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gaussian1dCapFloorEngine" "', argument " "1"" of type '" "Gaussian1dCapFloorEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dCapFloorEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dCapFloorEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dCapFloorEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dCapFloorEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dCapFloorEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gaussian1dCapFloorEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Gaussian1dCapFloorEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  Gaussian1dSwaptionEngine::Probabilities arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "7"" of type '" "Gaussian1dSwaptionEngine::Probabilities""'");
  } 
  arg7 = static_cast< Gaussian1dSwaptionEngine::Probabilities >(val7);
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< YieldTermStructure > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  Gaussian1dSwaptionEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Gaussian1dSwaptionEngine *)new Gaussian1dSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Gaussian1dSwaptionEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Gaussian1dSwaptionEngine__SWIG_6(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Gaussian1dSwaptionEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Gaussian1dSwaptionEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Gaussian1dSwaptionEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Gaussian1dSwaptionEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Gaussian1dSwaptionEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Gaussian1dSwaptionEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Gaussian1dSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< YieldTermStructure > const &,Gaussian1dSwaptionEngine::Probabilities const)\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< YieldTermStructure > const &)\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const)\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const)\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const)\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const)\n"
    "    Gaussian1dSwaptionEngine::Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Gaussian1dSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dSwaptionEngine *arg1 = (Gaussian1dSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dSwaptionEngine > tempshared1 ;
  ext::shared_ptr< Gaussian1dSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gaussian1dSwaptionEngine" "', argument " "1"" of type '" "Gaussian1dSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gaussian1dSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Gaussian1dSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Gaussian1dJamshidianSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  PyObject *swig_obj[1] ;
  Gaussian1dJamshidianSwaptionEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dJamshidianSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Gaussian1dJamshidianSwaptionEngine *)new Gaussian1dJamshidianSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Gaussian1dJamshidianSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dJamshidianSwaptionEngine *arg1 = (Gaussian1dJamshidianSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > tempshared1 ;
  ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gaussian1dJamshidianSwaptionEngine" "', argument " "1"" of type '" "Gaussian1dJamshidianSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dJamshidianSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dJamshidianSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dJamshidianSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gaussian1dJamshidianSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Gaussian1dJamshidianSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  Gaussian1dNonstandardSwaptionEngine::Probabilities arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "8"" of type '" "Gaussian1dNonstandardSwaptionEngine::Probabilities""'");
  } 
  arg8 = static_cast< Gaussian1dNonstandardSwaptionEngine::Probabilities >(val8);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  Gaussian1dNonstandardSwaptionEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Gaussian1dNonstandardSwaptionEngine *)new Gaussian1dNonstandardSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dNonstandardSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Gaussian1dNonstandardSwaptionEngine", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_7(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_6(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_1(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Gaussian1dNonstandardSwaptionEngine__SWIG_0(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Gaussian1dNonstandardSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &,Handle< YieldTermStructure > const &,Gaussian1dNonstandardSwaptionEngine::Probabilities const)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &,Handle< YieldTermStructure > const &)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const)\n"
    "    Gaussian1dNonstandardSwaptionEngine::Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Gaussian1dNonstandardSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dNonstandardSwaptionEngine *arg1 = (Gaussian1dNonstandardSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > tempshared1 ;
  ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gaussian1dNonstandardSwaptionEngine" "', argument " "1"" of type '" "Gaussian1dNonstandardSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dNonstandardSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dNonstandardSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dNonstandardSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gaussian1dNonstandardSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Gaussian1dNonstandardSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  Gaussian1dFloatFloatSwaptionEngine::Probabilities arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "9"" of type '" "Gaussian1dFloatFloatSwaptionEngine::Probabilities""'");
  } 
  arg9 = static_cast< Gaussian1dFloatFloatSwaptionEngine::Probabilities >(val9);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  bool arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  Handle< YieldTermStructure > *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "7"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg7 = reinterpret_cast< Handle< YieldTermStructure > * >(argp7);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6,(Handle< YieldTermStructure > const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  Handle< Quote > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "6"" of type '" "Handle< Quote > const &""'"); 
  }
  arg6 = reinterpret_cast< Handle< Quote > * >(argp6);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5,(Handle< Quote > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Gaussian1dModel > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dModel > tempshared1 ;
  Gaussian1dFloatFloatSwaptionEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< Gaussian1dModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Gaussian1dModel > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Gaussian1dFloatFloatSwaptionEngine *)new Gaussian1dFloatFloatSwaptionEngine((ext::shared_ptr< Gaussian1dModel > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Gaussian1dFloatFloatSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Gaussian1dFloatFloatSwaptionEngine", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_8(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_7(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_6(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Gaussian1dFloatFloatSwaptionEngine__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Gaussian1dFloatFloatSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &,Handle< YieldTermStructure > const &,bool const,Gaussian1dFloatFloatSwaptionEngine::Probabilities const)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &,Handle< YieldTermStructure > const &,bool const)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &,Handle< YieldTermStructure > const &)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const,Handle< Quote > const &)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const,bool const)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const,bool const)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const,Real const)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &,int const)\n"
    "    Gaussian1dFloatFloatSwaptionEngine::Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Gaussian1dFloatFloatSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Gaussian1dFloatFloatSwaptionEngine *arg1 = (Gaussian1dFloatFloatSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > tempshared1 ;
  ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Gaussian1dFloatFloatSwaptionEngine" "', argument " "1"" of type '" "Gaussian1dFloatFloatSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dFloatFloatSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Gaussian1dFloatFloatSwaptionEngine > * >(argp1);
      arg1 = const_cast< Gaussian1dFloatFloatSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Gaussian1dFloatFloatSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Gaussian1dFloatFloatSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SegmentIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SegmentIntegral *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SegmentIntegral" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (SegmentIntegral *)new SegmentIntegral(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SegmentIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SegmentIntegral_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SegmentIntegral *arg1 = (SegmentIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SegmentIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SegmentIntegral_numberOfEvaluations" "', argument " "1"" of type '" "SegmentIntegral const *""'"); 
  }
  arg1 = reinterpret_cast< SegmentIntegral * >(argp1);
  {
    try {
      result = ((SegmentIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SegmentIntegral___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SegmentIntegral *arg1 = (SegmentIntegral *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SegmentIntegral___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SegmentIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SegmentIntegral___call__" "', argument " "1"" of type '" "SegmentIntegral *""'"); 
  }
  arg1 = reinterpret_cast< SegmentIntegral * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SegmentIntegral___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SegmentIntegral___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)SegmentIntegral___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SegmentIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SegmentIntegral *arg1 = (SegmentIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SegmentIntegral, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SegmentIntegral" "', argument " "1"" of type '" "SegmentIntegral *""'"); 
  }
  arg1 = reinterpret_cast< SegmentIntegral * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SegmentIntegral_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SegmentIntegral, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SegmentIntegral_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TrapezoidIntegralDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  TrapezoidIntegral< Default > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TrapezoidIntegralDefault", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TrapezoidIntegralDefault" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TrapezoidIntegralDefault" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TrapezoidIntegral< Default > *)new TrapezoidIntegral< Default >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TrapezoidIntegralT_Default_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrapezoidIntegralDefault_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TrapezoidIntegral< Default > *arg1 = (TrapezoidIntegral< Default > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TrapezoidIntegralT_Default_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrapezoidIntegralDefault_numberOfEvaluations" "', argument " "1"" of type '" "TrapezoidIntegral< Default > const *""'"); 
  }
  arg1 = reinterpret_cast< TrapezoidIntegral< Default > * >(argp1);
  {
    try {
      result = ((TrapezoidIntegral< Default > const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrapezoidIntegralDefault___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TrapezoidIntegral< Default > *arg1 = (TrapezoidIntegral< Default > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "TrapezoidIntegralDefault___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TrapezoidIntegralT_Default_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrapezoidIntegralDefault___call__" "', argument " "1"" of type '" "TrapezoidIntegral< Default > *""'"); 
  }
  arg1 = reinterpret_cast< TrapezoidIntegral< Default > * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TrapezoidIntegralDefault___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TrapezoidIntegralDefault___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)TrapezoidIntegral_Sl_Default_Sg____call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TrapezoidIntegralDefault(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TrapezoidIntegral< Default > *arg1 = (TrapezoidIntegral< Default > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TrapezoidIntegralT_Default_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrapezoidIntegralDefault" "', argument " "1"" of type '" "TrapezoidIntegral< Default > *""'"); 
  }
  arg1 = reinterpret_cast< TrapezoidIntegral< Default > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrapezoidIntegralDefault_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TrapezoidIntegralT_Default_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TrapezoidIntegralDefault_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TrapezoidIntegralMidPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  TrapezoidIntegral< MidPoint > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TrapezoidIntegralMidPoint", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TrapezoidIntegralMidPoint" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TrapezoidIntegralMidPoint" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TrapezoidIntegral< MidPoint > *)new TrapezoidIntegral< MidPoint >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TrapezoidIntegralT_MidPoint_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrapezoidIntegralMidPoint_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TrapezoidIntegral< MidPoint > *arg1 = (TrapezoidIntegral< MidPoint > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TrapezoidIntegralT_MidPoint_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrapezoidIntegralMidPoint_numberOfEvaluations" "', argument " "1"" of type '" "TrapezoidIntegral< MidPoint > const *""'"); 
  }
  arg1 = reinterpret_cast< TrapezoidIntegral< MidPoint > * >(argp1);
  {
    try {
      result = ((TrapezoidIntegral< MidPoint > const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrapezoidIntegralMidPoint___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TrapezoidIntegral< MidPoint > *arg1 = (TrapezoidIntegral< MidPoint > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "TrapezoidIntegralMidPoint___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TrapezoidIntegralT_MidPoint_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrapezoidIntegralMidPoint___call__" "', argument " "1"" of type '" "TrapezoidIntegral< MidPoint > *""'"); 
  }
  arg1 = reinterpret_cast< TrapezoidIntegral< MidPoint > * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TrapezoidIntegralMidPoint___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TrapezoidIntegralMidPoint___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)TrapezoidIntegral_Sl_MidPoint_Sg____call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TrapezoidIntegralMidPoint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TrapezoidIntegral< MidPoint > *arg1 = (TrapezoidIntegral< MidPoint > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TrapezoidIntegralT_MidPoint_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrapezoidIntegralMidPoint" "', argument " "1"" of type '" "TrapezoidIntegral< MidPoint > *""'"); 
  }
  arg1 = reinterpret_cast< TrapezoidIntegral< MidPoint > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrapezoidIntegralMidPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TrapezoidIntegralT_MidPoint_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TrapezoidIntegralMidPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SimpsonIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SimpsonIntegral *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SimpsonIntegral", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SimpsonIntegral" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SimpsonIntegral" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (SimpsonIntegral *)new SimpsonIntegral(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SimpsonIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpsonIntegral_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpsonIntegral *arg1 = (SimpsonIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpsonIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpsonIntegral_numberOfEvaluations" "', argument " "1"" of type '" "SimpsonIntegral const *""'"); 
  }
  arg1 = reinterpret_cast< SimpsonIntegral * >(argp1);
  {
    try {
      result = ((SimpsonIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SimpsonIntegral___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpsonIntegral *arg1 = (SimpsonIntegral *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SimpsonIntegral___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpsonIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpsonIntegral___call__" "', argument " "1"" of type '" "SimpsonIntegral *""'"); 
  }
  arg1 = reinterpret_cast< SimpsonIntegral * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SimpsonIntegral___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SimpsonIntegral___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)SimpsonIntegral___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SimpsonIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SimpsonIntegral *arg1 = (SimpsonIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SimpsonIntegral, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpsonIntegral" "', argument " "1"" of type '" "SimpsonIntegral *""'"); 
  }
  arg1 = reinterpret_cast< SimpsonIntegral * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SimpsonIntegral_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SimpsonIntegral, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SimpsonIntegral_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussKronrodAdaptive__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  GaussKronrodAdaptive *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussKronrodAdaptive" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussKronrodAdaptive" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (GaussKronrodAdaptive *)new GaussKronrodAdaptive(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussKronrodAdaptive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussKronrodAdaptive__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  GaussKronrodAdaptive *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussKronrodAdaptive" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (GaussKronrodAdaptive *)new GaussKronrodAdaptive(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussKronrodAdaptive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussKronrodAdaptive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussKronrodAdaptive", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GaussKronrodAdaptive__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_GaussKronrodAdaptive__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussKronrodAdaptive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GaussKronrodAdaptive::GaussKronrodAdaptive(Real,Size)\n"
    "    GaussKronrodAdaptive::GaussKronrodAdaptive(Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussKronrodAdaptive_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussKronrodAdaptive *arg1 = (GaussKronrodAdaptive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussKronrodAdaptive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussKronrodAdaptive_numberOfEvaluations" "', argument " "1"" of type '" "GaussKronrodAdaptive const *""'"); 
  }
  arg1 = reinterpret_cast< GaussKronrodAdaptive * >(argp1);
  {
    try {
      result = ((GaussKronrodAdaptive const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussKronrodAdaptive___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussKronrodAdaptive *arg1 = (GaussKronrodAdaptive *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussKronrodAdaptive___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussKronrodAdaptive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussKronrodAdaptive___call__" "', argument " "1"" of type '" "GaussKronrodAdaptive *""'"); 
  }
  arg1 = reinterpret_cast< GaussKronrodAdaptive * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussKronrodAdaptive___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GaussKronrodAdaptive___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)GaussKronrodAdaptive___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussKronrodAdaptive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussKronrodAdaptive *arg1 = (GaussKronrodAdaptive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussKronrodAdaptive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussKronrodAdaptive" "', argument " "1"" of type '" "GaussKronrodAdaptive *""'"); 
  }
  arg1 = reinterpret_cast< GaussKronrodAdaptive * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussKronrodAdaptive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussKronrodAdaptive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussKronrodAdaptive_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussKronrodNonAdaptive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  GaussKronrodNonAdaptive *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GaussKronrodNonAdaptive", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussKronrodNonAdaptive" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussKronrodNonAdaptive" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussKronrodNonAdaptive" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (GaussKronrodNonAdaptive *)new GaussKronrodNonAdaptive(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussKronrodNonAdaptive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussKronrodNonAdaptive_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussKronrodNonAdaptive *arg1 = (GaussKronrodNonAdaptive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussKronrodNonAdaptive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussKronrodNonAdaptive_numberOfEvaluations" "', argument " "1"" of type '" "GaussKronrodNonAdaptive const *""'"); 
  }
  arg1 = reinterpret_cast< GaussKronrodNonAdaptive * >(argp1);
  {
    try {
      result = ((GaussKronrodNonAdaptive const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussKronrodNonAdaptive___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussKronrodNonAdaptive *arg1 = (GaussKronrodNonAdaptive *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussKronrodNonAdaptive___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussKronrodNonAdaptive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussKronrodNonAdaptive___call__" "', argument " "1"" of type '" "GaussKronrodNonAdaptive *""'"); 
  }
  arg1 = reinterpret_cast< GaussKronrodNonAdaptive * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussKronrodNonAdaptive___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GaussKronrodNonAdaptive___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)GaussKronrodNonAdaptive___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussKronrodNonAdaptive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussKronrodNonAdaptive *arg1 = (GaussKronrodNonAdaptive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussKronrodNonAdaptive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussKronrodNonAdaptive" "', argument " "1"" of type '" "GaussKronrodNonAdaptive *""'"); 
  }
  arg1 = reinterpret_cast< GaussKronrodNonAdaptive * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussKronrodNonAdaptive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussKronrodNonAdaptive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussKronrodNonAdaptive_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussLobattoIntegral__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  GaussLobattoIntegral *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLobattoIntegral" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussLobattoIntegral" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussLobattoIntegral" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussLobattoIntegral" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (GaussLobattoIntegral *)new GaussLobattoIntegral(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussLobattoIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussLobattoIntegral__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  GaussLobattoIntegral *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLobattoIntegral" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussLobattoIntegral" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussLobattoIntegral" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (GaussLobattoIntegral *)new GaussLobattoIntegral(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussLobattoIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussLobattoIntegral__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  GaussLobattoIntegral *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLobattoIntegral" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussLobattoIntegral" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GaussLobattoIntegral *)new GaussLobattoIntegral(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussLobattoIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussLobattoIntegral(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussLobattoIntegral", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_GaussLobattoIntegral__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_GaussLobattoIntegral__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussLobattoIntegral__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussLobattoIntegral'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GaussLobattoIntegral::GaussLobattoIntegral(Size,Real,Real,bool)\n"
    "    GaussLobattoIntegral::GaussLobattoIntegral(Size,Real,Real)\n"
    "    GaussLobattoIntegral::GaussLobattoIntegral(Size,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussLobattoIntegral_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussLobattoIntegral *arg1 = (GaussLobattoIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLobattoIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLobattoIntegral_numberOfEvaluations" "', argument " "1"" of type '" "GaussLobattoIntegral const *""'"); 
  }
  arg1 = reinterpret_cast< GaussLobattoIntegral * >(argp1);
  {
    try {
      result = ((GaussLobattoIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussLobattoIntegral___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussLobattoIntegral *arg1 = (GaussLobattoIntegral *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussLobattoIntegral___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLobattoIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLobattoIntegral___call__" "', argument " "1"" of type '" "GaussLobattoIntegral *""'"); 
  }
  arg1 = reinterpret_cast< GaussLobattoIntegral * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussLobattoIntegral___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GaussLobattoIntegral___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)GaussLobattoIntegral___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussLobattoIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussLobattoIntegral *arg1 = (GaussLobattoIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLobattoIntegral, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussLobattoIntegral" "', argument " "1"" of type '" "GaussLobattoIntegral *""'"); 
  }
  arg1 = reinterpret_cast< GaussLobattoIntegral * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussLobattoIntegral_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussLobattoIntegral, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussLobattoIntegral_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_GaussianQuadrature_order(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianQuadrature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianQuadrature_order" "', argument " "1"" of type '" "GaussianQuadrature const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianQuadrature * >(argp1);
  {
    try {
      result = ((GaussianQuadrature const *)arg1)->order();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianQuadrature_weights(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianQuadrature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianQuadrature_weights" "', argument " "1"" of type '" "GaussianQuadrature *""'"); 
  }
  arg1 = reinterpret_cast< GaussianQuadrature * >(argp1);
  {
    try {
      result = GaussianQuadrature_weights(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianQuadrature_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianQuadrature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianQuadrature_x" "', argument " "1"" of type '" "GaussianQuadrature *""'"); 
  }
  arg1 = reinterpret_cast< GaussianQuadrature * >(argp1);
  {
    try {
      result = GaussianQuadrature_x(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianQuadrature___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "GaussianQuadrature___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianQuadrature, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianQuadrature___call__" "', argument " "1"" of type '" "GaussianQuadrature *""'"); 
  }
  arg1 = reinterpret_cast< GaussianQuadrature * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)GaussianQuadrature___call__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianQuadrature(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianQuadrature *arg1 = (GaussianQuadrature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianQuadrature, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianQuadrature" "', argument " "1"" of type '" "GaussianQuadrature *""'"); 
  }
  arg1 = reinterpret_cast< GaussianQuadrature * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianQuadrature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussianQuadrature, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GaussLaguerreIntegration__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  GaussLaguerreIntegration *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLaguerreIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussLaguerreIntegration" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GaussLaguerreIntegration *)new GaussLaguerreIntegration(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussLaguerreIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussLaguerreIntegration__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  GaussLaguerreIntegration *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLaguerreIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GaussLaguerreIntegration *)new GaussLaguerreIntegration(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussLaguerreIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussLaguerreIntegration(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussLaguerreIntegration", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GaussLaguerreIntegration__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_GaussLaguerreIntegration__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussLaguerreIntegration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GaussLaguerreIntegration::GaussLaguerreIntegration(Size,Real)\n"
    "    GaussLaguerreIntegration::GaussLaguerreIntegration(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GaussLaguerreIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussLaguerreIntegration *arg1 = (GaussLaguerreIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLaguerreIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussLaguerreIntegration" "', argument " "1"" of type '" "GaussLaguerreIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussLaguerreIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussLaguerreIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussLaguerreIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussLaguerreIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussHermiteIntegration__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  GaussHermiteIntegration *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussHermiteIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussHermiteIntegration" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GaussHermiteIntegration *)new GaussHermiteIntegration(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussHermiteIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussHermiteIntegration__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  GaussHermiteIntegration *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussHermiteIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GaussHermiteIntegration *)new GaussHermiteIntegration(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussHermiteIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussHermiteIntegration(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussHermiteIntegration", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GaussHermiteIntegration__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_GaussHermiteIntegration__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussHermiteIntegration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GaussHermiteIntegration::GaussHermiteIntegration(Size,Real)\n"
    "    GaussHermiteIntegration::GaussHermiteIntegration(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GaussHermiteIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussHermiteIntegration *arg1 = (GaussHermiteIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussHermiteIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussHermiteIntegration" "', argument " "1"" of type '" "GaussHermiteIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussHermiteIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussHermiteIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussHermiteIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussHermiteIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussJacobiIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  Real arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  GaussJacobiIntegration *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GaussJacobiIntegration", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussJacobiIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussJacobiIntegration" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussJacobiIntegration" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (GaussJacobiIntegration *)new GaussJacobiIntegration(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussJacobiIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussJacobiIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussJacobiIntegration *arg1 = (GaussJacobiIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussJacobiIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussJacobiIntegration" "', argument " "1"" of type '" "GaussJacobiIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussJacobiIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussJacobiIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussJacobiIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussJacobiIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussHyperbolicIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussHyperbolicIntegration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussHyperbolicIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GaussHyperbolicIntegration *)new GaussHyperbolicIntegration(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussHyperbolicIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussHyperbolicIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussHyperbolicIntegration *arg1 = (GaussHyperbolicIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussHyperbolicIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussHyperbolicIntegration" "', argument " "1"" of type '" "GaussHyperbolicIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussHyperbolicIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussHyperbolicIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussHyperbolicIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussHyperbolicIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussLegendreIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussLegendreIntegration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLegendreIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GaussLegendreIntegration *)new GaussLegendreIntegration(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussLegendreIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussLegendreIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussLegendreIntegration *arg1 = (GaussLegendreIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussLegendreIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussLegendreIntegration" "', argument " "1"" of type '" "GaussLegendreIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussLegendreIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussLegendreIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussLegendreIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussLegendreIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussChebyshevIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussChebyshevIntegration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussChebyshevIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GaussChebyshevIntegration *)new GaussChebyshevIntegration(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussChebyshevIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussChebyshevIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussChebyshevIntegration *arg1 = (GaussChebyshevIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussChebyshevIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussChebyshevIntegration" "', argument " "1"" of type '" "GaussChebyshevIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussChebyshevIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussChebyshevIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussChebyshevIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussChebyshevIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussChebyshev2ndIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussChebyshev2ndIntegration *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussChebyshev2ndIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GaussChebyshev2ndIntegration *)new GaussChebyshev2ndIntegration(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussChebyshev2ndIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussChebyshev2ndIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussChebyshev2ndIntegration *arg1 = (GaussChebyshev2ndIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussChebyshev2ndIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussChebyshev2ndIntegration" "', argument " "1"" of type '" "GaussChebyshev2ndIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussChebyshev2ndIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussChebyshev2ndIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussChebyshev2ndIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussChebyshev2ndIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussGegenbauerIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  GaussGegenbauerIntegration *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GaussGegenbauerIntegration", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussGegenbauerIntegration" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussGegenbauerIntegration" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GaussGegenbauerIntegration *)new GaussGegenbauerIntegration(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussGegenbauerIntegration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussGegenbauerIntegration(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussGegenbauerIntegration *arg1 = (GaussGegenbauerIntegration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussGegenbauerIntegration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussGegenbauerIntegration" "', argument " "1"" of type '" "GaussGegenbauerIntegration *""'"); 
  }
  arg1 = reinterpret_cast< GaussGegenbauerIntegration * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussGegenbauerIntegration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussGegenbauerIntegration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussGegenbauerIntegration_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TanhSinhIntegral__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  TanhSinhIntegral *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TanhSinhIntegral" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TanhSinhIntegral" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TanhSinhIntegral" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TanhSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TanhSinhIntegral__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  TanhSinhIntegral *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TanhSinhIntegral" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TanhSinhIntegral" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TanhSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TanhSinhIntegral__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  TanhSinhIntegral *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TanhSinhIntegral" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TanhSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TanhSinhIntegral__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  TanhSinhIntegral *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (TanhSinhIntegral *)new TanhSinhIntegral();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TanhSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TanhSinhIntegral(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_TanhSinhIntegral", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_TanhSinhIntegral__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TanhSinhIntegral__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TanhSinhIntegral__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TanhSinhIntegral__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TanhSinhIntegral'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    TanhSinhIntegral::TanhSinhIntegral(Real,Size,Real)\n"
    "    TanhSinhIntegral::TanhSinhIntegral(Real,Size)\n"
    "    TanhSinhIntegral::TanhSinhIntegral(Real)\n"
    "    TanhSinhIntegral::TanhSinhIntegral()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TanhSinhIntegral_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TanhSinhIntegral *arg1 = (TanhSinhIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TanhSinhIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TanhSinhIntegral_numberOfEvaluations" "', argument " "1"" of type '" "TanhSinhIntegral const *""'"); 
  }
  arg1 = reinterpret_cast< TanhSinhIntegral * >(argp1);
  {
    try {
      result = ((TanhSinhIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TanhSinhIntegral___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TanhSinhIntegral *arg1 = (TanhSinhIntegral *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "TanhSinhIntegral___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TanhSinhIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TanhSinhIntegral___call__" "', argument " "1"" of type '" "TanhSinhIntegral *""'"); 
  }
  arg1 = reinterpret_cast< TanhSinhIntegral * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TanhSinhIntegral___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TanhSinhIntegral___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)TanhSinhIntegral___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TanhSinhIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TanhSinhIntegral *arg1 = (TanhSinhIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TanhSinhIntegral, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TanhSinhIntegral" "', argument " "1"" of type '" "TanhSinhIntegral *""'"); 
  }
  arg1 = reinterpret_cast< TanhSinhIntegral * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TanhSinhIntegral_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TanhSinhIntegral, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TanhSinhIntegral_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ExpSinhIntegral__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Size arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  ExpSinhIntegral *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpSinhIntegral" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExpSinhIntegral" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (ExpSinhIntegral *)new ExpSinhIntegral(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExpSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpSinhIntegral__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  ExpSinhIntegral *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpSinhIntegral" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (ExpSinhIntegral *)new ExpSinhIntegral(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExpSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpSinhIntegral__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  ExpSinhIntegral *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (ExpSinhIntegral *)new ExpSinhIntegral();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ExpSinhIntegral, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpSinhIntegral(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExpSinhIntegral", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ExpSinhIntegral__SWIG_2(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ExpSinhIntegral__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExpSinhIntegral__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExpSinhIntegral'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExpSinhIntegral::ExpSinhIntegral(Real,Size)\n"
    "    ExpSinhIntegral::ExpSinhIntegral(Real)\n"
    "    ExpSinhIntegral::ExpSinhIntegral()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ExpSinhIntegral_integrate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "ExpSinhIntegral_integrate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExpSinhIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpSinhIntegral_integrate" "', argument " "1"" of type '" "ExpSinhIntegral *""'"); 
  }
  arg1 = reinterpret_cast< ExpSinhIntegral * >(argp1);
  arg2 = swig_obj[1];
  {
    try {
      result = (Real)ExpSinhIntegral_integrate(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExpSinhIntegral_numberOfEvaluations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExpSinhIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpSinhIntegral_numberOfEvaluations" "', argument " "1"" of type '" "ExpSinhIntegral const *""'"); 
  }
  arg1 = reinterpret_cast< ExpSinhIntegral * >(argp1);
  {
    try {
      result = ((ExpSinhIntegral const *)arg1)->numberOfEvaluations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ExpSinhIntegral___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "ExpSinhIntegral___call__", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExpSinhIntegral, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpSinhIntegral___call__" "', argument " "1"" of type '" "ExpSinhIntegral *""'"); 
  }
  arg1 = reinterpret_cast< ExpSinhIntegral * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExpSinhIntegral___call__" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ExpSinhIntegral___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (Real)ExpSinhIntegral___call__(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ExpSinhIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExpSinhIntegral *arg1 = (ExpSinhIntegral *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ExpSinhIntegral, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpSinhIntegral" "', argument " "1"" of type '" "ExpSinhIntegral *""'"); 
  }
  arg1 = reinterpret_cast< ExpSinhIntegral * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpSinhIntegral_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ExpSinhIntegral, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExpSinhIntegral_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LocalConstantVol__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Volatility arg2 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  LocalConstantVol *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Volatility""'");
  } 
  arg2 = static_cast< Volatility >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol((Date const &)*arg1,arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalConstantVol > *smartresult = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalConstantVol__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  LocalConstantVol *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol((Date const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalConstantVol > *smartresult = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalConstantVol__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Volatility arg3 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  LocalConstantVol *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalConstantVol" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "Volatility""'");
  } 
  arg3 = static_cast< Volatility >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LocalConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol(arg1,(Calendar const &)*arg2,arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalConstantVol > *smartresult = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalConstantVol__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Integer arg1 ;
  Calendar *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  LocalConstantVol *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalConstantVol" "', argument " "1"" of type '" "Integer""'");
  } 
  arg1 = static_cast< Integer >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LocalConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalConstantVol" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (LocalConstantVol *)new LocalConstantVol(arg1,(Calendar const &)*arg2,(Handle< Quote > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalConstantVol > *smartresult = result ? new ext::shared_ptr<  LocalConstantVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalConstantVol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalConstantVol", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LocalConstantVol__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LocalConstantVol__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LocalConstantVol__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LocalConstantVol__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalConstantVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LocalConstantVol::LocalConstantVol(Date const &,Volatility,DayCounter const &)\n"
    "    LocalConstantVol::LocalConstantVol(Date const &,Handle< Quote > const &,DayCounter const &)\n"
    "    LocalConstantVol::LocalConstantVol(Integer,Calendar const &,Volatility,DayCounter const &)\n"
    "    LocalConstantVol::LocalConstantVol(Integer,Calendar const &,Handle< Quote > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocalConstantVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LocalConstantVol *arg1 = (LocalConstantVol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalConstantVol > tempshared1 ;
  ext::shared_ptr< LocalConstantVol > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalConstantVol" "', argument " "1"" of type '" "LocalConstantVol *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LocalConstantVol > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LocalConstantVol > * >(argp1);
      arg1 = const_cast< LocalConstantVol * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LocalConstantVol > * >(argp1);
      arg1 = const_cast< LocalConstantVol * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocalConstantVol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LocalConstantVol_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LocalConstantVol_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LocalVolSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  LocalVolSurface *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LocalVolSurface" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  {
    try {
      result = (LocalVolSurface *)new LocalVolSurface((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolSurface > *smartresult = result ? new ext::shared_ptr<  LocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalVolSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  LocalVolSurface *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalVolSurface" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (LocalVolSurface *)new LocalVolSurface((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolSurface > *smartresult = result ? new ext::shared_ptr<  LocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocalVolSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LocalVolSurface", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LocalVolSurface__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LocalVolSurface__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LocalVolSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LocalVolSurface::LocalVolSurface(Handle< BlackVolTermStructure > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &)\n"
    "    LocalVolSurface::LocalVolSurface(Handle< BlackVolTermStructure > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocalVolSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LocalVolSurface *arg1 = (LocalVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolSurface > tempshared1 ;
  ext::shared_ptr< LocalVolSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalVolSurface" "', argument " "1"" of type '" "LocalVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LocalVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LocalVolSurface > * >(argp1);
      arg1 = const_cast< LocalVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LocalVolSurface > * >(argp1);
      arg1 = const_cast< LocalVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocalVolSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LocalVolSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LocalVolSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NoExceptLocalVolSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Handle< Quote > *arg4 = 0 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  NoExceptLocalVolSurface *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoExceptLocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoExceptLocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoExceptLocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NoExceptLocalVolSurface" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "4"" of type '" "Handle< Quote > const &""'"); 
  }
  arg4 = reinterpret_cast< Handle< Quote > * >(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoExceptLocalVolSurface" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (NoExceptLocalVolSurface *)new NoExceptLocalVolSurface((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,(Handle< Quote > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoExceptLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  NoExceptLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoExceptLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExceptLocalVolSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< BlackVolTermStructure > *arg1 = 0 ;
  Handle< YieldTermStructure > *arg2 = 0 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  NoExceptLocalVolSurface *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_BlackVolTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoExceptLocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "1"" of type '" "Handle< BlackVolTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< BlackVolTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NoExceptLocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "2"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< YieldTermStructure > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NoExceptLocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExceptLocalVolSurface" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NoExceptLocalVolSurface" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_NoExceptLocalVolSurface" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (NoExceptLocalVolSurface *)new NoExceptLocalVolSurface((Handle< BlackVolTermStructure > const &)*arg1,(Handle< YieldTermStructure > const &)*arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NoExceptLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  NoExceptLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NoExceptLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExceptLocalVolSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NoExceptLocalVolSurface", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_NoExceptLocalVolSurface__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_BlackVolTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_NoExceptLocalVolSurface__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NoExceptLocalVolSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NoExceptLocalVolSurface::NoExceptLocalVolSurface(Handle< BlackVolTermStructure > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Handle< Quote > const &,Real)\n"
    "    NoExceptLocalVolSurface::NoExceptLocalVolSurface(Handle< BlackVolTermStructure > const &,Handle< YieldTermStructure > const &,Handle< YieldTermStructure > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoExceptLocalVolSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NoExceptLocalVolSurface *arg1 = (NoExceptLocalVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NoExceptLocalVolSurface > tempshared1 ;
  ext::shared_ptr< NoExceptLocalVolSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NoExceptLocalVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoExceptLocalVolSurface" "', argument " "1"" of type '" "NoExceptLocalVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NoExceptLocalVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NoExceptLocalVolSurface > * >(argp1);
      arg1 = const_cast< NoExceptLocalVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NoExceptLocalVolSurface > * >(argp1);
      arg1 = const_cast< NoExceptLocalVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoExceptLocalVolSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NoExceptLocalVolSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NoExceptLocalVolSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  FixedLocalVolSurface::Extrapolation arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedLocalVolSurface" "', argument " "6"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< FixedLocalVolSurface::Extrapolation >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedLocalVolSurface" "', argument " "7"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg7 = static_cast< FixedLocalVolSurface::Extrapolation >(val7);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedLocalVolSurface" "', argument " "6"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< FixedLocalVolSurface::Extrapolation >(val6);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  FixedLocalVolSurface::Extrapolation arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedLocalVolSurface" "', argument " "6"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< FixedLocalVolSurface::Extrapolation >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedLocalVolSurface" "', argument " "7"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg7 = static_cast< FixedLocalVolSurface::Extrapolation >(val7);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_3((Date const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedLocalVolSurface" "', argument " "6"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< FixedLocalVolSurface::Extrapolation >(val6);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_3((Date const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_3((Date const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  FixedLocalVolSurface::Extrapolation arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedLocalVolSurface" "', argument " "6"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< FixedLocalVolSurface::Extrapolation >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_FixedLocalVolSurface" "', argument " "7"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg7 = static_cast< FixedLocalVolSurface::Extrapolation >(val7);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_6((Date const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  FixedLocalVolSurface::Extrapolation arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FixedLocalVolSurface" "', argument " "6"" of type '" "FixedLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< FixedLocalVolSurface::Extrapolation >(val6);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_6((Date const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg3 = 0 ;
  Matrix arg4 ;
  DayCounter *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Matrix *m4 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  FixedLocalVolSurface *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[3]) || PyList_Check(swig_obj[3])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[3]) ?
      PyTuple_Size(swig_obj[3]) :
        PyList_Size(swig_obj[3]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[3],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      arg4 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[3],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              arg4[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              arg4[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res4)) {
        SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      }
      if (!argp4) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "4"" of type '" "Matrix""'");
      } else {
        arg4 = *(reinterpret_cast< Matrix * >(argp4));
      }
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedLocalVolSurface" "', argument " "5"" of type '" "DayCounter const &""'"); 
  }
  arg5 = reinterpret_cast< DayCounter * >(argp5);
  {
    try {
      result = (FixedLocalVolSurface *)new_FixedLocalVolSurface__SWIG_6((Date const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,SWIG_STD_MOVE(arg4),(DayCounter const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FixedLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  FixedLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FixedLocalVolSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FixedLocalVolSurface", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FixedLocalVolSurface__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FixedLocalVolSurface__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_FixedLocalVolSurface__SWIG_8(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FixedLocalVolSurface__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FixedLocalVolSurface__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_FixedLocalVolSurface__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FixedLocalVolSurface__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FixedLocalVolSurface__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            /* native sequence? */
            if (PyTuple_Check(argv[3]) || PyList_Check(argv[3])) {
              _v = 1;
              /* wrapped Matrix? */
            } else {
              // copied from SWIGTYPE typemap -- might need updating for newer SWIG
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
          }
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_FixedLocalVolSurface__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FixedLocalVolSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Matrix,DayCounter const &,FixedLocalVolSurface::Extrapolation,FixedLocalVolSurface::Extrapolation)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Matrix,DayCounter const &,FixedLocalVolSurface::Extrapolation)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< Real,std::allocator< Real > > const &,Matrix,DayCounter const &)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Time,std::allocator< Time > > const &,std::vector< Real,std::allocator< Real > > const &,Matrix,DayCounter const &,FixedLocalVolSurface::Extrapolation,FixedLocalVolSurface::Extrapolation)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Time,std::allocator< Time > > const &,std::vector< Real,std::allocator< Real > > const &,Matrix,DayCounter const &,FixedLocalVolSurface::Extrapolation)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Time,std::allocator< Time > > const &,std::vector< Real,std::allocator< Real > > const &,Matrix,DayCounter const &)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Time,std::allocator< Time > > const &,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &,Matrix,DayCounter const &,FixedLocalVolSurface::Extrapolation,FixedLocalVolSurface::Extrapolation)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Time,std::allocator< Time > > const &,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &,Matrix,DayCounter const &,FixedLocalVolSurface::Extrapolation)\n"
    "    FixedLocalVolSurface::FixedLocalVolSurface(Date const &,std::vector< Time,std::allocator< Time > > const &,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &,Matrix,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FixedLocalVolSurface_setInterpolation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FixedLocalVolSurface *arg1 = (FixedLocalVolSurface *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedLocalVolSurface > tempshared1 ;
  ext::shared_ptr< FixedLocalVolSurface > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedLocalVolSurface_setInterpolation" "', argument " "1"" of type '" "FixedLocalVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      arg1 = const_cast< FixedLocalVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      arg1 = const_cast< FixedLocalVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedLocalVolSurface_setInterpolation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedLocalVolSurface_setInterpolation" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      FixedLocalVolSurface_setInterpolation__SWIG_0(arg1,(std::string const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedLocalVolSurface_setInterpolation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  FixedLocalVolSurface *arg1 = (FixedLocalVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedLocalVolSurface > tempshared1 ;
  ext::shared_ptr< FixedLocalVolSurface > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedLocalVolSurface_setInterpolation" "', argument " "1"" of type '" "FixedLocalVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      arg1 = const_cast< FixedLocalVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      arg1 = const_cast< FixedLocalVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      FixedLocalVolSurface_setInterpolation__SWIG_0(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FixedLocalVolSurface_setInterpolation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "FixedLocalVolSurface_setInterpolation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FixedLocalVolSurface_setInterpolation__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FixedLocalVolSurface_setInterpolation__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FixedLocalVolSurface_setInterpolation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FixedLocalVolSurface::setInterpolation(std::string const &)\n"
    "    FixedLocalVolSurface::setInterpolation()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FixedLocalVolSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FixedLocalVolSurface *arg1 = (FixedLocalVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FixedLocalVolSurface > tempshared1 ;
  ext::shared_ptr< FixedLocalVolSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedLocalVolSurface" "', argument " "1"" of type '" "FixedLocalVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      arg1 = const_cast< FixedLocalVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FixedLocalVolSurface > * >(argp1);
      arg1 = const_cast< FixedLocalVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FixedLocalVolSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FixedLocalVolSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FixedLocalVolSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GridModelLocalVolSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  GridModelLocalVolSurface::Extrapolation arg5 ;
  GridModelLocalVolSurface::Extrapolation arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  GridModelLocalVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridModelLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridModelLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridModelLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GridModelLocalVolSurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridModelLocalVolSurface" "', argument " "5"" of type '" "GridModelLocalVolSurface::Extrapolation""'");
  } 
  arg5 = static_cast< GridModelLocalVolSurface::Extrapolation >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GridModelLocalVolSurface" "', argument " "6"" of type '" "GridModelLocalVolSurface::Extrapolation""'");
  } 
  arg6 = static_cast< GridModelLocalVolSurface::Extrapolation >(val6);
  {
    try {
      result = (GridModelLocalVolSurface *)new_GridModelLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,(DayCounter const &)*arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GridModelLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  GridModelLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GridModelLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GridModelLocalVolSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  GridModelLocalVolSurface::Extrapolation arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  GridModelLocalVolSurface *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridModelLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridModelLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridModelLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GridModelLocalVolSurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GridModelLocalVolSurface" "', argument " "5"" of type '" "GridModelLocalVolSurface::Extrapolation""'");
  } 
  arg5 = static_cast< GridModelLocalVolSurface::Extrapolation >(val5);
  {
    try {
      result = (GridModelLocalVolSurface *)new_GridModelLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,(DayCounter const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GridModelLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  GridModelLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GridModelLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GridModelLocalVolSurface__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  std::vector< Date,std::allocator< Date > > *arg2 = 0 ;
  std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > *arg3 = 0 ;
  DayCounter *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  GridModelLocalVolSurface *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridModelLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridModelLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "2"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridModelLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "3"" of type '" "std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GridModelLocalVolSurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridModelLocalVolSurface" "', argument " "4"" of type '" "DayCounter const &""'"); 
  }
  arg4 = reinterpret_cast< DayCounter * >(argp4);
  {
    try {
      result = (GridModelLocalVolSurface *)new_GridModelLocalVolSurface__SWIG_0((Date const &)*arg1,(std::vector< Date,std::allocator< Date > > const &)*arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3,(DayCounter const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  GridModelLocalVolSurface > *smartresult = result ? new ext::shared_ptr<  GridModelLocalVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_GridModelLocalVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GridModelLocalVolSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GridModelLocalVolSurface", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_GridModelLocalVolSurface__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_GridModelLocalVolSurface__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< Date,std::allocator< Date > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_GridModelLocalVolSurface__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GridModelLocalVolSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GridModelLocalVolSurface::GridModelLocalVolSurface(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &,DayCounter const &,GridModelLocalVolSurface::Extrapolation,GridModelLocalVolSurface::Extrapolation)\n"
    "    GridModelLocalVolSurface::GridModelLocalVolSurface(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &,DayCounter const &,GridModelLocalVolSurface::Extrapolation)\n"
    "    GridModelLocalVolSurface::GridModelLocalVolSurface(Date const &,std::vector< Date,std::allocator< Date > > const &,std::vector< std::vector< Real,std::allocator< Real > >,std::allocator< std::vector< Real,std::allocator< Real > > > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GridModelLocalVolSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GridModelLocalVolSurface *arg1 = (GridModelLocalVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< GridModelLocalVolSurface > tempshared1 ;
  ext::shared_ptr< GridModelLocalVolSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GridModelLocalVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridModelLocalVolSurface" "', argument " "1"" of type '" "GridModelLocalVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  GridModelLocalVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  GridModelLocalVolSurface > * >(argp1);
      arg1 = const_cast< GridModelLocalVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  GridModelLocalVolSurface > * >(argp1);
      arg1 = const_cast< GridModelLocalVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GridModelLocalVolSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_GridModelLocalVolSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GridModelLocalVolSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SampleNumber_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Real > *arg1 = (Sample< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleNumber_value" "', argument " "1"" of type '" "Sample< Real > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Real > * >(argp1);
  {
    try {
      result = (double *) &Sample_Sl_Real_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampleNumber_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Real > *arg1 = (Sample< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleNumber_weight" "', argument " "1"" of type '" "Sample< Real > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Real > * >(argp1);
  {
    try {
      result = (Real)Sample_Sl_Real_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SampleNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Real > *arg1 = (Sample< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SampleNumber" "', argument " "1"" of type '" "Sample< Real > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Real > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SampleNumber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SampleT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SampleArray_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Array > *arg1 = (Sample< Array > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_Array_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleArray_value" "', argument " "1"" of type '" "Sample< Array > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Array > * >(argp1);
  {
    try {
      result = (Array *) &Sample_Sl_Array_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampleArray_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Array > *arg1 = (Sample< Array > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_Array_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleArray_weight" "', argument " "1"" of type '" "Sample< Array > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Array > * >(argp1);
  {
    try {
      result = (Real)Sample_Sl_Array_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SampleArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Array > *arg1 = (Sample< Array > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_Array_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SampleArray" "', argument " "1"" of type '" "Sample< Array > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Array > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SampleArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SampleT_Array_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SampleRealVector_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< std::vector< Real > > *arg1 = (Sample< std::vector< Real > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleRealVector_value" "', argument " "1"" of type '" "Sample< std::vector< Real > > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< std::vector< Real > > * >(argp1);
  {
    try {
      result = (std::vector< double,std::allocator< double > > *) &Sample_Sl_std_vector_Sl_Real_Sg__Sg__value(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampleRealVector_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< std::vector< Real > > *arg1 = (Sample< std::vector< Real > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleRealVector_weight" "', argument " "1"" of type '" "Sample< std::vector< Real > > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< std::vector< Real > > * >(argp1);
  {
    try {
      result = (Real)Sample_Sl_std_vector_Sl_Real_Sg__Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SampleRealVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< std::vector< Real > > *arg1 = (Sample< std::vector< Real > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SampleRealVector" "', argument " "1"" of type '" "Sample< std::vector< Real > > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< std::vector< Real > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SampleRealVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LecuyerUniformRng__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BigInteger arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  LecuyerUniformRng *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LecuyerUniformRng" "', argument " "1"" of type '" "BigInteger""'");
  } 
  arg1 = static_cast< BigInteger >(val1);
  {
    try {
      result = (LecuyerUniformRng *)new LecuyerUniformRng(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LecuyerUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LecuyerUniformRng__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (LecuyerUniformRng *)new LecuyerUniformRng();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LecuyerUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LecuyerUniformRng(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LecuyerUniformRng", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_LecuyerUniformRng__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LecuyerUniformRng__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LecuyerUniformRng'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LecuyerUniformRng::LecuyerUniformRng(BigInteger)\n"
    "    LecuyerUniformRng::LecuyerUniformRng()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LecuyerUniformRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *arg1 = (LecuyerUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LecuyerUniformRng, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LecuyerUniformRng_next" "', argument " "1"" of type '" "LecuyerUniformRng const *""'"); 
  }
  arg1 = reinterpret_cast< LecuyerUniformRng * >(argp1);
  {
    try {
      result = ((LecuyerUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LecuyerUniformRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *arg1 = (LecuyerUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LecuyerUniformRng, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LecuyerUniformRng" "', argument " "1"" of type '" "LecuyerUniformRng *""'"); 
  }
  arg1 = reinterpret_cast< LecuyerUniformRng * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LecuyerUniformRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LecuyerUniformRng, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LecuyerUniformRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KnuthUniformRng__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BigInteger arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  KnuthUniformRng *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KnuthUniformRng" "', argument " "1"" of type '" "BigInteger""'");
  } 
  arg1 = static_cast< BigInteger >(val1);
  {
    try {
      result = (KnuthUniformRng *)new KnuthUniformRng(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KnuthUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KnuthUniformRng__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  KnuthUniformRng *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (KnuthUniformRng *)new KnuthUniformRng();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KnuthUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KnuthUniformRng(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KnuthUniformRng", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_KnuthUniformRng__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_KnuthUniformRng__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KnuthUniformRng'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    KnuthUniformRng::KnuthUniformRng(BigInteger)\n"
    "    KnuthUniformRng::KnuthUniformRng()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KnuthUniformRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnuthUniformRng *arg1 = (KnuthUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KnuthUniformRng, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KnuthUniformRng_next" "', argument " "1"" of type '" "KnuthUniformRng const *""'"); 
  }
  arg1 = reinterpret_cast< KnuthUniformRng * >(argp1);
  {
    try {
      result = ((KnuthUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KnuthUniformRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnuthUniformRng *arg1 = (KnuthUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_KnuthUniformRng, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KnuthUniformRng" "', argument " "1"" of type '" "KnuthUniformRng *""'"); 
  }
  arg1 = reinterpret_cast< KnuthUniformRng * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KnuthUniformRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_KnuthUniformRng, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KnuthUniformRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRng__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BigInteger arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  MersenneTwisterUniformRng *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MersenneTwisterUniformRng" "', argument " "1"" of type '" "BigInteger""'");
  } 
  arg1 = static_cast< BigInteger >(val1);
  {
    try {
      result = (MersenneTwisterUniformRng *)new MersenneTwisterUniformRng(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MersenneTwisterUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRng__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (MersenneTwisterUniformRng *)new MersenneTwisterUniformRng();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MersenneTwisterUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRng(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MersenneTwisterUniformRng", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MersenneTwisterUniformRng__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MersenneTwisterUniformRng__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MersenneTwisterUniformRng'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MersenneTwisterUniformRng::MersenneTwisterUniformRng(BigInteger)\n"
    "    MersenneTwisterUniformRng::MersenneTwisterUniformRng()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MersenneTwisterUniformRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *arg1 = (MersenneTwisterUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MersenneTwisterUniformRng, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MersenneTwisterUniformRng_next" "', argument " "1"" of type '" "MersenneTwisterUniformRng const *""'"); 
  }
  arg1 = reinterpret_cast< MersenneTwisterUniformRng * >(argp1);
  {
    try {
      result = ((MersenneTwisterUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MersenneTwisterUniformRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *arg1 = (MersenneTwisterUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MersenneTwisterUniformRng, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MersenneTwisterUniformRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng *""'"); 
  }
  arg1 = reinterpret_cast< MersenneTwisterUniformRng * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MersenneTwisterUniformRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MersenneTwisterUniformRng, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MersenneTwisterUniformRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRng__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BigInteger arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  Xoshiro256StarStarUniformRng *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Xoshiro256StarStarUniformRng" "', argument " "1"" of type '" "BigInteger""'");
  } 
  arg1 = static_cast< BigInteger >(val1);
  {
    try {
      result = (Xoshiro256StarStarUniformRng *)new Xoshiro256StarStarUniformRng(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xoshiro256StarStarUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRng__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Xoshiro256StarStarUniformRng *)new Xoshiro256StarStarUniformRng();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Xoshiro256StarStarUniformRng, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRng(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Xoshiro256StarStarUniformRng", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_Xoshiro256StarStarUniformRng__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Xoshiro256StarStarUniformRng__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Xoshiro256StarStarUniformRng'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Xoshiro256StarStarUniformRng::Xoshiro256StarStarUniformRng(BigInteger)\n"
    "    Xoshiro256StarStarUniformRng::Xoshiro256StarStarUniformRng()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Xoshiro256StarStarUniformRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *arg1 = (Xoshiro256StarStarUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xoshiro256StarStarUniformRng, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Xoshiro256StarStarUniformRng_next" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const *""'"); 
  }
  arg1 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp1);
  {
    try {
      result = ((Xoshiro256StarStarUniformRng const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Xoshiro256StarStarUniformRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *arg1 = (Xoshiro256StarStarUniformRng *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Xoshiro256StarStarUniformRng, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Xoshiro256StarStarUniformRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng *""'"); 
  }
  arg1 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Xoshiro256StarStarUniformRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Xoshiro256StarStarUniformRng, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Xoshiro256StarStarUniformRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UniformRandomGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  BigInteger arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  UniformRandomGenerator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UniformRandomGenerator" "', argument " "1"" of type '" "BigInteger""'");
  } 
  arg1 = static_cast< BigInteger >(val1);
  {
    try {
      result = (UniformRandomGenerator *)new UniformRandomGenerator(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UniformRandomGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UniformRandomGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  UniformRandomGenerator *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (UniformRandomGenerator *)new UniformRandomGenerator();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UniformRandomGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UniformRandomGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UniformRandomGenerator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UniformRandomGenerator__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UniformRandomGenerator__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UniformRandomGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UniformRandomGenerator::UniformRandomGenerator(BigInteger)\n"
    "    UniformRandomGenerator::UniformRandomGenerator()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UniformRandomGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomGenerator *arg1 = (UniformRandomGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformRandomGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UniformRandomGenerator_next" "', argument " "1"" of type '" "UniformRandomGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomGenerator * >(argp1);
  {
    try {
      result = ((UniformRandomGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UniformRandomGenerator_nextValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomGenerator *arg1 = (UniformRandomGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformRandomGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UniformRandomGenerator_nextValue" "', argument " "1"" of type '" "UniformRandomGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomGenerator * >(argp1);
  {
    try {
      result = (Real)UniformRandomGenerator_nextValue((UniformRandomGenerator const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UniformRandomGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomGenerator *arg1 = (UniformRandomGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformRandomGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UniformRandomGenerator" "', argument " "1"" of type '" "UniformRandomGenerator *""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UniformRandomGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_UniformRandomGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UniformRandomGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CentralLimitLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CLGaussianRng< LecuyerUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LecuyerUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CentralLimitLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CentralLimitLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< LecuyerUniformRng * >(argp1);
  {
    try {
      result = (CLGaussianRng< LecuyerUniformRng > *)new CLGaussianRng< LecuyerUniformRng >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CLGaussianRngT_LecuyerUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CentralLimitLecuyerGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< LecuyerUniformRng > *arg1 = (CLGaussianRng< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_LecuyerUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CentralLimitLecuyerGaussianRng_next" "', argument " "1"" of type '" "CLGaussianRng< LecuyerUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< LecuyerUniformRng > * >(argp1);
  {
    try {
      result = ((CLGaussianRng< LecuyerUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< LecuyerUniformRng > *arg1 = (CLGaussianRng< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_LecuyerUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CentralLimitLecuyerGaussianRng" "', argument " "1"" of type '" "CLGaussianRng< LecuyerUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< LecuyerUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CentralLimitLecuyerGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CLGaussianRngT_LecuyerUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CentralLimitLecuyerGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CentralLimitKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnuthUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CLGaussianRng< KnuthUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_KnuthUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CentralLimitKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CentralLimitKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< KnuthUniformRng * >(argp1);
  {
    try {
      result = (CLGaussianRng< KnuthUniformRng > *)new CLGaussianRng< KnuthUniformRng >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CLGaussianRngT_KnuthUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CentralLimitKnuthGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< KnuthUniformRng > *arg1 = (CLGaussianRng< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_KnuthUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CentralLimitKnuthGaussianRng_next" "', argument " "1"" of type '" "CLGaussianRng< KnuthUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< KnuthUniformRng > * >(argp1);
  {
    try {
      result = ((CLGaussianRng< KnuthUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< KnuthUniformRng > *arg1 = (CLGaussianRng< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_KnuthUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CentralLimitKnuthGaussianRng" "', argument " "1"" of type '" "CLGaussianRng< KnuthUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< KnuthUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CentralLimitKnuthGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CLGaussianRngT_KnuthUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CentralLimitKnuthGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CentralLimitMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CLGaussianRng< MersenneTwisterUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MersenneTwisterUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CentralLimitMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CentralLimitMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< MersenneTwisterUniformRng * >(argp1);
  {
    try {
      result = (CLGaussianRng< MersenneTwisterUniformRng > *)new CLGaussianRng< MersenneTwisterUniformRng >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CLGaussianRngT_MersenneTwisterUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CentralLimitMersenneTwisterGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< MersenneTwisterUniformRng > *arg1 = (CLGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_MersenneTwisterUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CentralLimitMersenneTwisterGaussianRng_next" "', argument " "1"" of type '" "CLGaussianRng< MersenneTwisterUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      result = ((CLGaussianRng< MersenneTwisterUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< MersenneTwisterUniformRng > *arg1 = (CLGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_MersenneTwisterUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CentralLimitMersenneTwisterGaussianRng" "', argument " "1"" of type '" "CLGaussianRng< MersenneTwisterUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CentralLimitMersenneTwisterGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CLGaussianRngT_MersenneTwisterUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CentralLimitMersenneTwisterGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CentralLimitXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  CLGaussianRng< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xoshiro256StarStarUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CentralLimitXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CentralLimitXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp1);
  {
    try {
      result = (CLGaussianRng< Xoshiro256StarStarUniformRng > *)new CLGaussianRng< Xoshiro256StarStarUniformRng >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CLGaussianRngT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CentralLimitXoshiro256StarStarGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (CLGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_Xoshiro256StarStarUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CentralLimitXoshiro256StarStarGaussianRng_next" "', argument " "1"" of type '" "CLGaussianRng< Xoshiro256StarStarUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      result = ((CLGaussianRng< Xoshiro256StarStarUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CentralLimitXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CLGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (CLGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLGaussianRngT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CentralLimitXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "CLGaussianRng< Xoshiro256StarStarUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< CLGaussianRng< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CentralLimitXoshiro256StarStarGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CLGaussianRngT_Xoshiro256StarStarUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CentralLimitXoshiro256StarStarGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BoxMullerLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BoxMullerGaussianRng< LecuyerUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LecuyerUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoxMullerLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoxMullerLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< LecuyerUniformRng * >(argp1);
  {
    try {
      result = (BoxMullerGaussianRng< LecuyerUniformRng > *)new BoxMullerGaussianRng< LecuyerUniformRng >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoxMullerGaussianRngT_LecuyerUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoxMullerLecuyerGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< LecuyerUniformRng > *arg1 = (BoxMullerGaussianRng< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_LecuyerUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxMullerLecuyerGaussianRng_next" "', argument " "1"" of type '" "BoxMullerGaussianRng< LecuyerUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< LecuyerUniformRng > * >(argp1);
  {
    try {
      result = ((BoxMullerGaussianRng< LecuyerUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< LecuyerUniformRng > *arg1 = (BoxMullerGaussianRng< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_LecuyerUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoxMullerLecuyerGaussianRng" "', argument " "1"" of type '" "BoxMullerGaussianRng< LecuyerUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< LecuyerUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoxMullerLecuyerGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BoxMullerGaussianRngT_LecuyerUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BoxMullerLecuyerGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BoxMullerKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnuthUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BoxMullerGaussianRng< KnuthUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_KnuthUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoxMullerKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoxMullerKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< KnuthUniformRng * >(argp1);
  {
    try {
      result = (BoxMullerGaussianRng< KnuthUniformRng > *)new BoxMullerGaussianRng< KnuthUniformRng >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoxMullerGaussianRngT_KnuthUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoxMullerKnuthGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< KnuthUniformRng > *arg1 = (BoxMullerGaussianRng< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_KnuthUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxMullerKnuthGaussianRng_next" "', argument " "1"" of type '" "BoxMullerGaussianRng< KnuthUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< KnuthUniformRng > * >(argp1);
  {
    try {
      result = ((BoxMullerGaussianRng< KnuthUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< KnuthUniformRng > *arg1 = (BoxMullerGaussianRng< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_KnuthUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoxMullerKnuthGaussianRng" "', argument " "1"" of type '" "BoxMullerGaussianRng< KnuthUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< KnuthUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoxMullerKnuthGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BoxMullerGaussianRngT_KnuthUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BoxMullerKnuthGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BoxMullerMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BoxMullerGaussianRng< MersenneTwisterUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MersenneTwisterUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoxMullerMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoxMullerMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< MersenneTwisterUniformRng * >(argp1);
  {
    try {
      result = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *)new BoxMullerGaussianRng< MersenneTwisterUniformRng >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoxMullerMersenneTwisterGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< MersenneTwisterUniformRng > *arg1 = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxMullerMersenneTwisterGaussianRng_next" "', argument " "1"" of type '" "BoxMullerGaussianRng< MersenneTwisterUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      result = ((BoxMullerGaussianRng< MersenneTwisterUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< MersenneTwisterUniformRng > *arg1 = (BoxMullerGaussianRng< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoxMullerMersenneTwisterGaussianRng" "', argument " "1"" of type '" "BoxMullerGaussianRng< MersenneTwisterUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoxMullerMersenneTwisterGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BoxMullerGaussianRngT_MersenneTwisterUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BoxMullerMersenneTwisterGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BoxMullerXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xoshiro256StarStarUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoxMullerXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoxMullerXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp1);
  {
    try {
      result = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *)new BoxMullerGaussianRng< Xoshiro256StarStarUniformRng >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BoxMullerGaussianRngT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoxMullerXoshiro256StarStarGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_Xoshiro256StarStarUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxMullerXoshiro256StarStarGaussianRng_next" "', argument " "1"" of type '" "BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      result = ((BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoxMullerXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *arg1 = (BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BoxMullerGaussianRngT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoxMullerXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< BoxMullerGaussianRng< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoxMullerXoshiro256StarStarGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BoxMullerGaussianRngT_Xoshiro256StarStarUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BoxMullerXoshiro256StarStarGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LecuyerUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< LecuyerUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeLecuyerGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeLecuyerGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeLecuyerGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< LecuyerUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeLecuyerGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeLecuyerGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnuthUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_KnuthUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< KnuthUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeKnuthGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeKnuthGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeKnuthGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< KnuthUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeKnuthGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeKnuthGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MersenneTwisterUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< MersenneTwisterUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeMersenneTwisterGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeMersenneTwisterGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeMersenneTwisterGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< MersenneTwisterUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeMersenneTwisterGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeMersenneTwisterGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xoshiro256StarStarUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *)new InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeXoshiro256StarStarGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeXoshiro256StarStarGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< Xoshiro256StarStarUniformRng,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeXoshiro256StarStarGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeXoshiro256StarStarGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LecuyerUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_LecuyerUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeLecuyerGaussianRng" "', argument " "1"" of type '" "LecuyerUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< LecuyerUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal >((LecuyerUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeLecuyerGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeLecuyerGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeLecuyerGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeLecuyerGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< LecuyerUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeLecuyerGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_LecuyerUniformRng_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeLecuyerGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KnuthUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_KnuthUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeKnuthGaussianRng" "', argument " "1"" of type '" "KnuthUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< KnuthUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal >((KnuthUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeKnuthGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeKnuthGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeKnuthGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeKnuthGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< KnuthUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeKnuthGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_KnuthUniformRng_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeKnuthGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MersenneTwisterUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MersenneTwisterUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterGaussianRng" "', argument " "1"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< MersenneTwisterUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal >((MersenneTwisterUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeMersenneTwisterGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeMersenneTwisterGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< MersenneTwisterUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeMersenneTwisterGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_MersenneTwisterUniformRng_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeMersenneTwisterGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Xoshiro256StarStarUniformRng *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Xoshiro256StarStarUniformRng,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  arg1 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp1);
  {
    try {
      result = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *)new InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal >((Xoshiro256StarStarUniformRng const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeXoshiro256StarStarGaussianRng_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeXoshiro256StarStarGaussianRng_next" "', argument " "1"" of type '" "InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeXoshiro256StarStarGaussianRng(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *arg1 = (InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeXoshiro256StarStarGaussianRng" "', argument " "1"" of type '" "InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRng< Xoshiro256StarStarUniformRng,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeXoshiro256StarStarGaussianRng_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRngT_Xoshiro256StarStarUniformRng_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeXoshiro256StarStarGaussianRng_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussianRandomGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussianRandomGenerator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_UniformRandomGenerator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianRandomGenerator" "', argument " "1"" of type '" "UniformRandomGenerator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianRandomGenerator" "', argument " "1"" of type '" "UniformRandomGenerator const &""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomGenerator * >(argp1);
  {
    try {
      result = (GaussianRandomGenerator *)new GaussianRandomGenerator((UniformRandomGenerator const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussianRandomGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianRandomGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianRandomGenerator *arg1 = (GaussianRandomGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Sample< double > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianRandomGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianRandomGenerator_next" "', argument " "1"" of type '" "GaussianRandomGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianRandomGenerator * >(argp1);
  {
    try {
      result = ((GaussianRandomGenerator const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Sample< Real >(result)), SWIGTYPE_p_SampleT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianRandomGenerator_nextValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianRandomGenerator *arg1 = (GaussianRandomGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianRandomGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianRandomGenerator_nextValue" "', argument " "1"" of type '" "GaussianRandomGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianRandomGenerator * >(argp1);
  {
    try {
      result = (Real)GaussianRandomGenerator_nextValue((GaussianRandomGenerator const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianRandomGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianRandomGenerator *arg1 = (GaussianRandomGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianRandomGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianRandomGenerator" "', argument " "1"" of type '" "GaussianRandomGenerator *""'"); 
  }
  arg1 = reinterpret_cast< GaussianRandomGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianRandomGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussianRandomGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianRandomGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HaltonRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  unsigned long arg2 ;
  bool arg3 ;
  bool arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  HaltonRsg *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HaltonRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HaltonRsg" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HaltonRsg" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HaltonRsg" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltonRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  unsigned long arg2 ;
  bool arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  HaltonRsg *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HaltonRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HaltonRsg" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HaltonRsg" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltonRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  unsigned long arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  HaltonRsg *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HaltonRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HaltonRsg" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltonRsg__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  HaltonRsg *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HaltonRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (HaltonRsg *)new HaltonRsg(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltonRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HaltonRsg", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HaltonRsg__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HaltonRsg__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_HaltonRsg__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_HaltonRsg__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HaltonRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HaltonRsg::HaltonRsg(Size,unsigned long,bool,bool)\n"
    "    HaltonRsg::HaltonRsg(Size,unsigned long,bool)\n"
    "    HaltonRsg::HaltonRsg(Size,unsigned long)\n"
    "    HaltonRsg::HaltonRsg(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HaltonRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HaltonRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaltonRsg_nextSequence" "', argument " "1"" of type '" "HaltonRsg const *""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((HaltonRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaltonRsg_lastSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HaltonRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaltonRsg_lastSequence" "', argument " "1"" of type '" "HaltonRsg const *""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((HaltonRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HaltonRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HaltonRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HaltonRsg_dimension" "', argument " "1"" of type '" "HaltonRsg const *""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  {
    try {
      result = ((HaltonRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HaltonRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = (HaltonRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HaltonRsg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HaltonRsg" "', argument " "1"" of type '" "HaltonRsg *""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HaltonRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HaltonRsg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HaltonRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SobolRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SobolRsg *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolRsg" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SobolRsg" "', argument " "3"" of type '" "SobolRsg::DirectionIntegers""'");
  } 
  arg3 = static_cast< SobolRsg::DirectionIntegers >(val3);
  {
    try {
      result = (SobolRsg *)new SobolRsg(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  SobolRsg *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolRsg" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  {
    try {
      result = (SobolRsg *)new SobolRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  SobolRsg *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (SobolRsg *)new SobolRsg(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SobolRsg", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SobolRsg__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SobolRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SobolRsg__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SobolRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SobolRsg::SobolRsg(Size,BigInteger,SobolRsg::DirectionIntegers)\n"
    "    SobolRsg::SobolRsg(Size,BigInteger)\n"
    "    SobolRsg::SobolRsg(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SobolRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolRsg_nextSequence" "', argument " "1"" of type '" "SobolRsg const *""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((SobolRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolRsg_lastSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolRsg_lastSequence" "', argument " "1"" of type '" "SobolRsg const *""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((SobolRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolRsg_dimension" "', argument " "1"" of type '" "SobolRsg const *""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      result = ((SobolRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolRsg_skipTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SobolRsg_skipTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolRsg_skipTo" "', argument " "1"" of type '" "SobolRsg *""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SobolRsg_skipTo" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      (arg1)->skipTo(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolRsg_nextInt32Sequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolRsg_nextInt32Sequence" "', argument " "1"" of type '" "SobolRsg *""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      result = SobolRsg_nextInt32Sequence(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SobolRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = (SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolRsg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SobolRsg" "', argument " "1"" of type '" "SobolRsg *""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SobolRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SobolRsg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SobolRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Burley2020SobolRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  BigInteger arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  long val4 ;
  int ecode4 = 0 ;
  Burley2020SobolRsg *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Burley2020SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Burley2020SobolRsg" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Burley2020SobolRsg" "', argument " "3"" of type '" "SobolRsg::DirectionIntegers""'");
  } 
  arg3 = static_cast< SobolRsg::DirectionIntegers >(val3);
  ecode4 = SWIG_AsVal_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Burley2020SobolRsg" "', argument " "4"" of type '" "BigInteger""'");
  } 
  arg4 = static_cast< BigInteger >(val4);
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Burley2020SobolRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Burley2020SobolRsg *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Burley2020SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Burley2020SobolRsg" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Burley2020SobolRsg" "', argument " "3"" of type '" "SobolRsg::DirectionIntegers""'");
  } 
  arg3 = static_cast< SobolRsg::DirectionIntegers >(val3);
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Burley2020SobolRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Burley2020SobolRsg *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Burley2020SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Burley2020SobolRsg" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Burley2020SobolRsg__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  Burley2020SobolRsg *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Burley2020SobolRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (Burley2020SobolRsg *)new Burley2020SobolRsg(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Burley2020SobolRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Burley2020SobolRsg", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Burley2020SobolRsg__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Burley2020SobolRsg__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Burley2020SobolRsg__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Burley2020SobolRsg__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Burley2020SobolRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Burley2020SobolRsg::Burley2020SobolRsg(Size,BigInteger,SobolRsg::DirectionIntegers,BigInteger)\n"
    "    Burley2020SobolRsg::Burley2020SobolRsg(Size,BigInteger,SobolRsg::DirectionIntegers)\n"
    "    Burley2020SobolRsg::Burley2020SobolRsg(Size,BigInteger)\n"
    "    Burley2020SobolRsg::Burley2020SobolRsg(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolRsg_nextSequence" "', argument " "1"" of type '" "Burley2020SobolRsg const *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((Burley2020SobolRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolRsg_lastSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolRsg_lastSequence" "', argument " "1"" of type '" "Burley2020SobolRsg const *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((Burley2020SobolRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolRsg_dimension" "', argument " "1"" of type '" "Burley2020SobolRsg const *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      result = ((Burley2020SobolRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolRsg_nextInt32Sequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolRsg_nextInt32Sequence" "', argument " "1"" of type '" "Burley2020SobolRsg *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      result = Burley2020SobolRsg_nextInt32Sequence(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Burley2020SobolRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = (Burley2020SobolRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Burley2020SobolRsg" "', argument " "1"" of type '" "Burley2020SobolRsg *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Burley2020SobolRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Burley2020SobolRsg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Burley2020SobolRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SobolBrownianBridgeRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SobolBrownianBridgeRsg *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SobolBrownianBridgeRsg", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianBridgeRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolBrownianBridgeRsg" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (SobolBrownianBridgeRsg *)new SobolBrownianBridgeRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SobolBrownianBridgeRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolBrownianBridgeRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolBrownianBridgeRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolBrownianBridgeRsg_nextSequence" "', argument " "1"" of type '" "SobolBrownianBridgeRsg const *""'"); 
  }
  arg1 = reinterpret_cast< SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((SobolBrownianBridgeRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolBrownianBridgeRsg_lastSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolBrownianBridgeRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolBrownianBridgeRsg_lastSequence" "', argument " "1"" of type '" "SobolBrownianBridgeRsg const *""'"); 
  }
  arg1 = reinterpret_cast< SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((SobolBrownianBridgeRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SobolBrownianBridgeRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolBrownianBridgeRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SobolBrownianBridgeRsg_dimension" "', argument " "1"" of type '" "SobolBrownianBridgeRsg const *""'"); 
  }
  arg1 = reinterpret_cast< SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      result = ((SobolBrownianBridgeRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SobolBrownianBridgeRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianBridgeRsg *arg1 = (SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SobolBrownianBridgeRsg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SobolBrownianBridgeRsg" "', argument " "1"" of type '" "SobolBrownianBridgeRsg *""'"); 
  }
  arg1 = reinterpret_cast< SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SobolBrownianBridgeRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SobolBrownianBridgeRsg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SobolBrownianBridgeRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Burley2020SobolBrownianBridgeRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Burley2020SobolBrownianBridgeRsg *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Burley2020SobolBrownianBridgeRsg", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Burley2020SobolBrownianBridgeRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Burley2020SobolBrownianBridgeRsg" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Burley2020SobolBrownianBridgeRsg *)new Burley2020SobolBrownianBridgeRsg(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolBrownianBridgeRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolBrownianBridgeRsg_nextSequence" "', argument " "1"" of type '" "Burley2020SobolBrownianBridgeRsg const *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((Burley2020SobolBrownianBridgeRsg const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolBrownianBridgeRsg_lastSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolBrownianBridgeRsg_lastSequence" "', argument " "1"" of type '" "Burley2020SobolBrownianBridgeRsg const *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((Burley2020SobolBrownianBridgeRsg const *)arg1)->lastSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Burley2020SobolBrownianBridgeRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Burley2020SobolBrownianBridgeRsg_dimension" "', argument " "1"" of type '" "Burley2020SobolBrownianBridgeRsg const *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      result = ((Burley2020SobolBrownianBridgeRsg const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Burley2020SobolBrownianBridgeRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Burley2020SobolBrownianBridgeRsg *arg1 = (Burley2020SobolBrownianBridgeRsg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Burley2020SobolBrownianBridgeRsg" "', argument " "1"" of type '" "Burley2020SobolBrownianBridgeRsg *""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolBrownianBridgeRsg * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Burley2020SobolBrownianBridgeRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Burley2020SobolBrownianBridgeRsg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Burley2020SobolBrownianBridgeRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LecuyerUniformRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  LecuyerUniformRng *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  RandomSequenceGenerator< LecuyerUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LecuyerUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_LecuyerUniformRng,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LecuyerUniformRsg" "', argument " "2"" of type '" "LecuyerUniformRng const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LecuyerUniformRsg" "', argument " "2"" of type '" "LecuyerUniformRng const &""'"); 
  }
  arg2 = reinterpret_cast< LecuyerUniformRng * >(argp2);
  {
    try {
      result = (RandomSequenceGenerator< LecuyerUniformRng > *)new RandomSequenceGenerator< LecuyerUniformRng >(arg1,(LecuyerUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LecuyerUniformRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigNatural arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  RandomSequenceGenerator< LecuyerUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LecuyerUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LecuyerUniformRsg" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (RandomSequenceGenerator< LecuyerUniformRng > *)new RandomSequenceGenerator< LecuyerUniformRng >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LecuyerUniformRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  RandomSequenceGenerator< LecuyerUniformRng > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LecuyerUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (RandomSequenceGenerator< LecuyerUniformRng > *)new RandomSequenceGenerator< LecuyerUniformRng >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LecuyerUniformRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LecuyerUniformRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LecuyerUniformRsg__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_LecuyerUniformRng, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LecuyerUniformRsg__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LecuyerUniformRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LecuyerUniformRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RandomSequenceGenerator< LecuyerUniformRng >::RandomSequenceGenerator(Size,LecuyerUniformRng const &)\n"
    "    RandomSequenceGenerator< LecuyerUniformRng >::RandomSequenceGenerator(Size,BigNatural)\n"
    "    RandomSequenceGenerator< LecuyerUniformRng >::RandomSequenceGenerator(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LecuyerUniformRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LecuyerUniformRsg_nextSequence" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((RandomSequenceGenerator< LecuyerUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LecuyerUniformRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LecuyerUniformRsg_dimension" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  {
    try {
      result = ((RandomSequenceGenerator< LecuyerUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LecuyerUniformRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = (RandomSequenceGenerator< LecuyerUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LecuyerUniformRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LecuyerUniformRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LecuyerUniformRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KnuthUniformRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  KnuthUniformRng *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  RandomSequenceGenerator< KnuthUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KnuthUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_KnuthUniformRng,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KnuthUniformRsg" "', argument " "2"" of type '" "KnuthUniformRng const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KnuthUniformRsg" "', argument " "2"" of type '" "KnuthUniformRng const &""'"); 
  }
  arg2 = reinterpret_cast< KnuthUniformRng * >(argp2);
  {
    try {
      result = (RandomSequenceGenerator< KnuthUniformRng > *)new RandomSequenceGenerator< KnuthUniformRng >(arg1,(KnuthUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KnuthUniformRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigNatural arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  RandomSequenceGenerator< KnuthUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KnuthUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KnuthUniformRsg" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (RandomSequenceGenerator< KnuthUniformRng > *)new RandomSequenceGenerator< KnuthUniformRng >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KnuthUniformRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  RandomSequenceGenerator< KnuthUniformRng > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KnuthUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (RandomSequenceGenerator< KnuthUniformRng > *)new RandomSequenceGenerator< KnuthUniformRng >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KnuthUniformRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KnuthUniformRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_KnuthUniformRsg__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_KnuthUniformRng, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_KnuthUniformRsg__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_KnuthUniformRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KnuthUniformRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RandomSequenceGenerator< KnuthUniformRng >::RandomSequenceGenerator(Size,KnuthUniformRng const &)\n"
    "    RandomSequenceGenerator< KnuthUniformRng >::RandomSequenceGenerator(Size,BigNatural)\n"
    "    RandomSequenceGenerator< KnuthUniformRng >::RandomSequenceGenerator(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KnuthUniformRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = (RandomSequenceGenerator< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KnuthUniformRsg_nextSequence" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((RandomSequenceGenerator< KnuthUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KnuthUniformRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = (RandomSequenceGenerator< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KnuthUniformRsg_dimension" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  {
    try {
      result = ((RandomSequenceGenerator< KnuthUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KnuthUniformRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = (RandomSequenceGenerator< KnuthUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KnuthUniformRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KnuthUniformRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KnuthUniformRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  MersenneTwisterUniformRng *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MersenneTwisterUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MersenneTwisterUniformRng,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MersenneTwisterUniformRsg" "', argument " "2"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MersenneTwisterUniformRsg" "', argument " "2"" of type '" "MersenneTwisterUniformRng const &""'"); 
  }
  arg2 = reinterpret_cast< MersenneTwisterUniformRng * >(argp2);
  {
    try {
      result = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)new RandomSequenceGenerator< MersenneTwisterUniformRng >(arg1,(MersenneTwisterUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigNatural arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MersenneTwisterUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MersenneTwisterUniformRsg" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)new RandomSequenceGenerator< MersenneTwisterUniformRng >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MersenneTwisterUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (RandomSequenceGenerator< MersenneTwisterUniformRng > *)new RandomSequenceGenerator< MersenneTwisterUniformRng >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MersenneTwisterUniformRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MersenneTwisterUniformRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MersenneTwisterUniformRsg__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MersenneTwisterUniformRng, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MersenneTwisterUniformRsg__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MersenneTwisterUniformRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MersenneTwisterUniformRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RandomSequenceGenerator< MersenneTwisterUniformRng >::RandomSequenceGenerator(Size,MersenneTwisterUniformRng const &)\n"
    "    RandomSequenceGenerator< MersenneTwisterUniformRng >::RandomSequenceGenerator(Size,BigNatural)\n"
    "    RandomSequenceGenerator< MersenneTwisterUniformRng >::RandomSequenceGenerator(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MersenneTwisterUniformRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MersenneTwisterUniformRsg_nextSequence" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((RandomSequenceGenerator< MersenneTwisterUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MersenneTwisterUniformRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MersenneTwisterUniformRsg_dimension" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      result = ((RandomSequenceGenerator< MersenneTwisterUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MersenneTwisterUniformRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = (RandomSequenceGenerator< MersenneTwisterUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MersenneTwisterUniformRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MersenneTwisterUniformRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MersenneTwisterUniformRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Xoshiro256StarStarUniformRng *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Xoshiro256StarStarUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Xoshiro256StarStarUniformRng,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Xoshiro256StarStarUniformRsg" "', argument " "2"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Xoshiro256StarStarUniformRsg" "', argument " "2"" of type '" "Xoshiro256StarStarUniformRng const &""'"); 
  }
  arg2 = reinterpret_cast< Xoshiro256StarStarUniformRng * >(argp2);
  {
    try {
      result = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)new RandomSequenceGenerator< Xoshiro256StarStarUniformRng >(arg1,(Xoshiro256StarStarUniformRng const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigNatural arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Xoshiro256StarStarUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Xoshiro256StarStarUniformRsg" "', argument " "2"" of type '" "BigNatural""'");
  } 
  arg2 = static_cast< BigNatural >(val2);
  {
    try {
      result = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)new RandomSequenceGenerator< Xoshiro256StarStarUniformRng >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRsg__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Xoshiro256StarStarUniformRsg" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *)new RandomSequenceGenerator< Xoshiro256StarStarUniformRng >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Xoshiro256StarStarUniformRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Xoshiro256StarStarUniformRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Xoshiro256StarStarUniformRsg__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Xoshiro256StarStarUniformRng, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Xoshiro256StarStarUniformRsg__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Xoshiro256StarStarUniformRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Xoshiro256StarStarUniformRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RandomSequenceGenerator< Xoshiro256StarStarUniformRng >::RandomSequenceGenerator(Size,Xoshiro256StarStarUniformRng const &)\n"
    "    RandomSequenceGenerator< Xoshiro256StarStarUniformRng >::RandomSequenceGenerator(Size,BigNatural)\n"
    "    RandomSequenceGenerator< Xoshiro256StarStarUniformRng >::RandomSequenceGenerator(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Xoshiro256StarStarUniformRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Xoshiro256StarStarUniformRsg_nextSequence" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Xoshiro256StarStarUniformRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Xoshiro256StarStarUniformRsg_dimension" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      result = ((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Xoshiro256StarStarUniformRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = (RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Xoshiro256StarStarUniformRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Xoshiro256StarStarUniformRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Xoshiro256StarStarUniformRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UniformRandomSequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  UniformRandomGenerator *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  UniformRandomSequenceGenerator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_UniformRandomSequenceGenerator", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UniformRandomSequenceGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_UniformRandomGenerator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UniformRandomSequenceGenerator" "', argument " "2"" of type '" "UniformRandomGenerator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UniformRandomSequenceGenerator" "', argument " "2"" of type '" "UniformRandomGenerator const &""'"); 
  }
  arg2 = reinterpret_cast< UniformRandomGenerator * >(argp2);
  {
    try {
      result = (UniformRandomSequenceGenerator *)new UniformRandomSequenceGenerator(arg1,(UniformRandomGenerator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UniformRandomSequenceGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UniformRandomSequenceGenerator_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomSequenceGenerator *arg1 = (UniformRandomSequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformRandomSequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UniformRandomSequenceGenerator_nextSequence" "', argument " "1"" of type '" "UniformRandomSequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomSequenceGenerator * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((UniformRandomSequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UniformRandomSequenceGenerator_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomSequenceGenerator *arg1 = (UniformRandomSequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformRandomSequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UniformRandomSequenceGenerator_dimension" "', argument " "1"" of type '" "UniformRandomSequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomSequenceGenerator * >(argp1);
  {
    try {
      result = ((UniformRandomSequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UniformRandomSequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomSequenceGenerator *arg1 = (UniformRandomSequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformRandomSequenceGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UniformRandomSequenceGenerator" "', argument " "1"" of type '" "UniformRandomSequenceGenerator *""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomSequenceGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UniformRandomSequenceGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_UniformRandomSequenceGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UniformRandomSequenceGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_UniformLowDiscrepancySequenceGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  UniformLowDiscrepancySequenceGenerator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UniformLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UniformLowDiscrepancySequenceGenerator" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UniformLowDiscrepancySequenceGenerator" "', argument " "3"" of type '" "SobolRsg::DirectionIntegers""'");
  } 
  arg3 = static_cast< SobolRsg::DirectionIntegers >(val3);
  {
    try {
      result = (UniformLowDiscrepancySequenceGenerator *)new UniformLowDiscrepancySequenceGenerator(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UniformLowDiscrepancySequenceGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  BigInteger arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  UniformLowDiscrepancySequenceGenerator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UniformLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UniformLowDiscrepancySequenceGenerator" "', argument " "2"" of type '" "BigInteger""'");
  } 
  arg2 = static_cast< BigInteger >(val2);
  {
    try {
      result = (UniformLowDiscrepancySequenceGenerator *)new UniformLowDiscrepancySequenceGenerator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UniformLowDiscrepancySequenceGenerator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  UniformLowDiscrepancySequenceGenerator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UniformLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (UniformLowDiscrepancySequenceGenerator *)new UniformLowDiscrepancySequenceGenerator(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UniformLowDiscrepancySequenceGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UniformLowDiscrepancySequenceGenerator", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UniformLowDiscrepancySequenceGenerator__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UniformLowDiscrepancySequenceGenerator__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UniformLowDiscrepancySequenceGenerator__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UniformLowDiscrepancySequenceGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    UniformLowDiscrepancySequenceGenerator::UniformLowDiscrepancySequenceGenerator(Size,BigInteger,SobolRsg::DirectionIntegers)\n"
    "    UniformLowDiscrepancySequenceGenerator::UniformLowDiscrepancySequenceGenerator(Size,BigInteger)\n"
    "    UniformLowDiscrepancySequenceGenerator::UniformLowDiscrepancySequenceGenerator(Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UniformLowDiscrepancySequenceGenerator_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformLowDiscrepancySequenceGenerator *arg1 = (UniformLowDiscrepancySequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UniformLowDiscrepancySequenceGenerator_nextSequence" "', argument " "1"" of type '" "UniformLowDiscrepancySequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< UniformLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((UniformLowDiscrepancySequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UniformLowDiscrepancySequenceGenerator_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformLowDiscrepancySequenceGenerator *arg1 = (UniformLowDiscrepancySequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UniformLowDiscrepancySequenceGenerator_dimension" "', argument " "1"" of type '" "UniformLowDiscrepancySequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< UniformLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      result = ((UniformLowDiscrepancySequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UniformLowDiscrepancySequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformLowDiscrepancySequenceGenerator *arg1 = (UniformLowDiscrepancySequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UniformLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "UniformLowDiscrepancySequenceGenerator *""'"); 
  }
  arg1 = reinterpret_cast< UniformLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UniformLowDiscrepancySequenceGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UniformLowDiscrepancySequenceGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeLecuyerGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeLecuyerGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeLecuyerGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeLecuyerGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeLecuyerGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeLecuyerGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeLecuyerGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< LecuyerUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< LecuyerUniformRng > const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeLecuyerGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeLecuyerGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeLecuyerGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeLecuyerGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeLecuyerGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeLecuyerGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeLecuyerGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeKnuthGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeKnuthGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeKnuthGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeKnuthGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeKnuthGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeKnuthGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeKnuthGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeKnuthGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeKnuthGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< KnuthUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< KnuthUniformRng > const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeKnuthGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeKnuthGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeKnuthGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeKnuthGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeKnuthGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeKnuthGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeKnuthGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeMersenneTwisterGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeMersenneTwisterGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< MersenneTwisterUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< MersenneTwisterUniformRng > const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeMersenneTwisterGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal >((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeXoshiro256StarStarGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeXoshiro256StarStarGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeXoshiro256StarStarGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeXoshiro256StarStarGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeXoshiro256StarStarGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeXoshiro256StarStarGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeXoshiro256StarStarGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeXoshiro256StarStarGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeHaltonGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HaltonRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal >((HaltonRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeHaltonGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HaltonRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeHaltonGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeHaltonGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal >((HaltonRsg const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeHaltonGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeHaltonGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeHaltonGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeHaltonGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeHaltonGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal >::InverseCumulativeRsg(HaltonRsg const &)\n"
    "    InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal >::InverseCumulativeRsg(HaltonRsg const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeHaltonGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeHaltonGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeHaltonGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeHaltonGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeHaltonGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< HaltonRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeHaltonGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeHaltonGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeSobolGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal >((SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeSobolGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeSobolGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeSobolGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal >((SobolRsg const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeSobolGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeSobolGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeSobolGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeSobolGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeSobolGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal >::InverseCumulativeRsg(SobolRsg const &)\n"
    "    InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal >::InverseCumulativeRsg(SobolRsg const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeSobolGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeSobolGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeSobolGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeSobolGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeSobolGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< SobolRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeSobolGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeSobolGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeBurley2020SobolGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Burley2020SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal >((Burley2020SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeBurley2020SobolGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = 0 ;
  MoroInverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Burley2020SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_MoroInverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "2"" of type '" "MoroInverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< MoroInverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *)new InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal >((Burley2020SobolRsg const &)*arg1,(MoroInverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoroInvCumulativeBurley2020SobolGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoroInvCumulativeBurley2020SobolGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoroInvCumulativeBurley2020SobolGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_MoroInverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoroInvCumulativeBurley2020SobolGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoroInvCumulativeBurley2020SobolGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal >::InverseCumulativeRsg(Burley2020SobolRsg const &)\n"
    "    InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal >::InverseCumulativeRsg(Burley2020SobolRsg const &,MoroInverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeBurley2020SobolGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeBurley2020SobolGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoroInvCumulativeBurley2020SobolGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoroInvCumulativeBurley2020SobolGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoroInvCumulativeBurley2020SobolGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoroInvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< Burley2020SobolRsg,MoroInverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoroInvCumulativeBurley2020SobolGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_MoroInverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoroInvCumulativeBurley2020SobolGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeLecuyerGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeLecuyerGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< LecuyerUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< LecuyerUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< LecuyerUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeLecuyerGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeLecuyerGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< LecuyerUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeLecuyerGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeLecuyerGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeLecuyerGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_LecuyerUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeLecuyerGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeLecuyerGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< LecuyerUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< LecuyerUniformRng > const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeLecuyerGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeLecuyerGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeLecuyerGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeLecuyerGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeLecuyerGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeLecuyerGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< LecuyerUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeLecuyerGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_LecuyerUniformRng_t_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeLecuyerGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeKnuthGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeKnuthGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< KnuthUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< KnuthUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< KnuthUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeKnuthGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeKnuthGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< KnuthUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeKnuthGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeKnuthGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeKnuthGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_KnuthUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeKnuthGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeKnuthGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< KnuthUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< KnuthUniformRng > const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeKnuthGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeKnuthGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeKnuthGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeKnuthGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeKnuthGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeKnuthGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< KnuthUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeKnuthGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_KnuthUniformRng_t_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeKnuthGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< MersenneTwisterUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< MersenneTwisterUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< MersenneTwisterUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< MersenneTwisterUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeMersenneTwisterGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeMersenneTwisterGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeMersenneTwisterGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeMersenneTwisterGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< MersenneTwisterUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< MersenneTwisterUniformRng > const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeMersenneTwisterGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeMersenneTwisterGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeMersenneTwisterGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeMersenneTwisterGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeXoshiro256StarStarGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeXoshiro256StarStarGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  RandomSequenceGenerator< Xoshiro256StarStarUniformRng > *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &""'"); 
  }
  arg1 = reinterpret_cast< RandomSequenceGenerator< Xoshiro256StarStarUniformRng > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *)new InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal >((RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeXoshiro256StarStarGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeXoshiro256StarStarGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeXoshiro256StarStarGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeXoshiro256StarStarGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeXoshiro256StarStarGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &)\n"
    "    InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal >::InverseCumulativeRsg(RandomSequenceGenerator< Xoshiro256StarStarUniformRng > const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeXoshiro256StarStarGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeXoshiro256StarStarGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeXoshiro256StarStarGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeXoshiro256StarStarGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeXoshiro256StarStarGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeXoshiro256StarStarGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< Xoshiro256StarStarUniformRng >,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeXoshiro256StarStarGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_Xoshiro256StarStarUniformRng_t_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeXoshiro256StarStarGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeHaltonGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HaltonRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal >((HaltonRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeHaltonGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  HaltonRsg *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HaltonRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "HaltonRsg const &""'"); 
  }
  arg1 = reinterpret_cast< HaltonRsg * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeHaltonGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeHaltonGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal >((HaltonRsg const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeHaltonGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeHaltonGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeHaltonGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HaltonRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeHaltonGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeHaltonGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal >::InverseCumulativeRsg(HaltonRsg const &)\n"
    "    InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal >::InverseCumulativeRsg(HaltonRsg const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeHaltonGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeHaltonGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeHaltonGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeHaltonGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeHaltonGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeHaltonGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< HaltonRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeHaltonGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_HaltonRsg_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeHaltonGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeSobolGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal >((SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeSobolGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolRsg *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< SobolRsg * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeSobolGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeSobolGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal >((SobolRsg const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeSobolGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeSobolGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeSobolGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeSobolGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeSobolGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal >::InverseCumulativeRsg(SobolRsg const &)\n"
    "    InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal >::InverseCumulativeRsg(SobolRsg const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeSobolGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeSobolGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeSobolGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeSobolGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeSobolGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeSobolGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< SobolRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeSobolGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_SobolRsg_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeSobolGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeBurley2020SobolGaussianRsg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Burley2020SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  {
    try {
      result = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal >((Burley2020SobolRsg const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeBurley2020SobolGaussianRsg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Burley2020SobolRsg *arg1 = 0 ;
  InverseCumulativeNormal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Burley2020SobolRsg,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "Burley2020SobolRsg const &""'"); 
  }
  arg1 = reinterpret_cast< Burley2020SobolRsg * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_InverseCumulativeNormal,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "2"" of type '" "InverseCumulativeNormal const &""'"); 
  }
  arg2 = reinterpret_cast< InverseCumulativeNormal * >(argp2);
  {
    try {
      result = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *)new InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal >((Burley2020SobolRsg const &)*arg1,(InverseCumulativeNormal const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeBurley2020SobolGaussianRsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeBurley2020SobolGaussianRsg", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvCumulativeBurley2020SobolGaussianRsg__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Burley2020SobolRsg, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_InverseCumulativeNormal, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_InvCumulativeBurley2020SobolGaussianRsg__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeBurley2020SobolGaussianRsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal >::InverseCumulativeRsg(Burley2020SobolRsg const &)\n"
    "    InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal >::InverseCumulativeRsg(Burley2020SobolRsg const &,InverseCumulativeNormal const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeBurley2020SobolGaussianRsg_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeBurley2020SobolGaussianRsg_nextSequence" "', argument " "1"" of type '" "InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeBurley2020SobolGaussianRsg_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeBurley2020SobolGaussianRsg_dimension" "', argument " "1"" of type '" "InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > const *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      result = ((InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeBurley2020SobolGaussianRsg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *arg1 = (InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeBurley2020SobolGaussianRsg" "', argument " "1"" of type '" "InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > *""'"); 
  }
  arg1 = reinterpret_cast< InverseCumulativeRsg< Burley2020SobolRsg,InverseCumulativeNormal > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeBurley2020SobolGaussianRsg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_InverseCumulativeRsgT_Burley2020SobolRsg_InverseCumulativeNormal_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeBurley2020SobolGaussianRsg_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussianRandomSequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformRandomSequenceGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussianRandomSequenceGenerator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_UniformRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianRandomSequenceGenerator" "', argument " "1"" of type '" "UniformRandomSequenceGenerator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianRandomSequenceGenerator" "', argument " "1"" of type '" "UniformRandomSequenceGenerator const &""'"); 
  }
  arg1 = reinterpret_cast< UniformRandomSequenceGenerator * >(argp1);
  {
    try {
      result = (GaussianRandomSequenceGenerator *)new GaussianRandomSequenceGenerator((UniformRandomSequenceGenerator const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianRandomSequenceGenerator_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianRandomSequenceGenerator *arg1 = (GaussianRandomSequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianRandomSequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianRandomSequenceGenerator_nextSequence" "', argument " "1"" of type '" "GaussianRandomSequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((GaussianRandomSequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianRandomSequenceGenerator_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianRandomSequenceGenerator *arg1 = (GaussianRandomSequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianRandomSequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianRandomSequenceGenerator_dimension" "', argument " "1"" of type '" "GaussianRandomSequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp1);
  {
    try {
      result = ((GaussianRandomSequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianRandomSequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianRandomSequenceGenerator *arg1 = (GaussianRandomSequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianRandomSequenceGenerator" "', argument " "1"" of type '" "GaussianRandomSequenceGenerator *""'"); 
  }
  arg1 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianRandomSequenceGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianRandomSequenceGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussianLowDiscrepancySequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  UniformLowDiscrepancySequenceGenerator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  GaussianLowDiscrepancySequenceGenerator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_UniformLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "UniformLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "UniformLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg1 = reinterpret_cast< UniformLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      result = (GaussianLowDiscrepancySequenceGenerator *)new GaussianLowDiscrepancySequenceGenerator((UniformLowDiscrepancySequenceGenerator const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianLowDiscrepancySequenceGenerator_nextSequence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianLowDiscrepancySequenceGenerator *arg1 = (GaussianLowDiscrepancySequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Sample< std::vector< Real,std::allocator< Real > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianLowDiscrepancySequenceGenerator_nextSequence" "', argument " "1"" of type '" "GaussianLowDiscrepancySequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      result = (Sample< std::vector< Real,std::allocator< Real > > > *) &((GaussianLowDiscrepancySequenceGenerator const *)arg1)->nextSequence();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianLowDiscrepancySequenceGenerator_dimension(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianLowDiscrepancySequenceGenerator *arg1 = (GaussianLowDiscrepancySequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianLowDiscrepancySequenceGenerator_dimension" "', argument " "1"" of type '" "GaussianLowDiscrepancySequenceGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      result = ((GaussianLowDiscrepancySequenceGenerator const *)arg1)->dimension();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianLowDiscrepancySequenceGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GaussianLowDiscrepancySequenceGenerator *arg1 = (GaussianLowDiscrepancySequenceGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianLowDiscrepancySequenceGenerator" "', argument " "1"" of type '" "GaussianLowDiscrepancySequenceGenerator *""'"); 
  }
  arg1 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianLowDiscrepancySequenceGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianLowDiscrepancySequenceGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_BrownianGenerator_nextStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGenerator > tempshared1 ;
  ext::shared_ptr< BrownianGenerator > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "BrownianGenerator_nextStep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianGenerator_nextStep" "', argument " "1"" of type '" "BrownianGenerator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrownianGenerator_nextStep" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BrownianGenerator_nextStep" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp2);
  {
    try {
      result = (Real)(arg1)->nextStep(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianGenerator_nextPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGenerator > tempshared1 ;
  ext::shared_ptr< BrownianGenerator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianGenerator_nextPath" "', argument " "1"" of type '" "BrownianGenerator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->nextPath();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianGenerator_numberOfFactors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGenerator const > tempshared1 ;
  ext::shared_ptr< BrownianGenerator const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianGenerator_numberOfFactors" "', argument " "1"" of type '" "BrownianGenerator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BrownianGenerator const *)arg1)->numberOfFactors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianGenerator_numberOfSteps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGenerator const > tempshared1 ;
  ext::shared_ptr< BrownianGenerator const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianGenerator_numberOfSteps" "', argument " "1"" of type '" "BrownianGenerator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((BrownianGenerator const *)arg1)->numberOfSteps();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BrownianGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGenerator *arg1 = (BrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGenerator > tempshared1 ;
  ext::shared_ptr< BrownianGenerator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BrownianGenerator" "', argument " "1"" of type '" "BrownianGenerator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BrownianGenerator > * >(argp1);
      arg1 = const_cast< BrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BrownianGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_BrownianGeneratorFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGeneratorFactory *arg1 = (BrownianGeneratorFactory *) 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory const > tempshared1 ;
  ext::shared_ptr< BrownianGeneratorFactory const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  ext::shared_ptr< BrownianGenerator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "BrownianGeneratorFactory_create", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianGeneratorFactory_create" "', argument " "1"" of type '" "BrownianGeneratorFactory const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< BrownianGeneratorFactory * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< BrownianGeneratorFactory * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BrownianGeneratorFactory_create" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BrownianGeneratorFactory_create" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = ((BrownianGeneratorFactory const *)arg1)->create(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BrownianGenerator > *smartresult = result ? new ext::shared_ptr<  BrownianGenerator >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BrownianGenerator_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BrownianGeneratorFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianGeneratorFactory *arg1 = (BrownianGeneratorFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared1 ;
  ext::shared_ptr< BrownianGeneratorFactory > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BrownianGeneratorFactory" "', argument " "1"" of type '" "BrownianGeneratorFactory *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BrownianGeneratorFactory > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< BrownianGeneratorFactory * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< BrownianGeneratorFactory * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BrownianGeneratorFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MTBrownianGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  unsigned long arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  MTBrownianGenerator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MTBrownianGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MTBrownianGenerator" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MTBrownianGenerator" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);
  {
    try {
      result = (MTBrownianGenerator *)new MTBrownianGenerator(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MTBrownianGenerator > *smartresult = result ? new ext::shared_ptr<  MTBrownianGenerator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MTBrownianGenerator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MTBrownianGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  MTBrownianGenerator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MTBrownianGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MTBrownianGenerator" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (MTBrownianGenerator *)new MTBrownianGenerator(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MTBrownianGenerator > *smartresult = result ? new ext::shared_ptr<  MTBrownianGenerator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MTBrownianGenerator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MTBrownianGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MTBrownianGenerator", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MTBrownianGenerator__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MTBrownianGenerator__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MTBrownianGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MTBrownianGenerator::MTBrownianGenerator(Size,Size,unsigned long)\n"
    "    MTBrownianGenerator::MTBrownianGenerator(Size,Size)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MTBrownianGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MTBrownianGenerator *arg1 = (MTBrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MTBrownianGenerator > tempshared1 ;
  ext::shared_ptr< MTBrownianGenerator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MTBrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MTBrownianGenerator" "', argument " "1"" of type '" "MTBrownianGenerator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MTBrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MTBrownianGenerator > * >(argp1);
      arg1 = const_cast< MTBrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MTBrownianGenerator > * >(argp1);
      arg1 = const_cast< MTBrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MTBrownianGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MTBrownianGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MTBrownianGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MTBrownianGeneratorFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned long arg1 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  MTBrownianGeneratorFactory *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MTBrownianGeneratorFactory" "', argument " "1"" of type '" "unsigned long""'");
  } 
  arg1 = static_cast< unsigned long >(val1);
  {
    try {
      result = (MTBrownianGeneratorFactory *)new MTBrownianGeneratorFactory(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MTBrownianGeneratorFactory > *smartresult = result ? new ext::shared_ptr<  MTBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MTBrownianGeneratorFactory_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MTBrownianGeneratorFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  MTBrownianGeneratorFactory *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (MTBrownianGeneratorFactory *)new MTBrownianGeneratorFactory();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MTBrownianGeneratorFactory > *smartresult = result ? new ext::shared_ptr<  MTBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MTBrownianGeneratorFactory_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MTBrownianGeneratorFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MTBrownianGeneratorFactory", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MTBrownianGeneratorFactory__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MTBrownianGeneratorFactory__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MTBrownianGeneratorFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MTBrownianGeneratorFactory::MTBrownianGeneratorFactory(unsigned long)\n"
    "    MTBrownianGeneratorFactory::MTBrownianGeneratorFactory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MTBrownianGeneratorFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MTBrownianGeneratorFactory *arg1 = (MTBrownianGeneratorFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MTBrownianGeneratorFactory > tempshared1 ;
  ext::shared_ptr< MTBrownianGeneratorFactory > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MTBrownianGeneratorFactory_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MTBrownianGeneratorFactory" "', argument " "1"" of type '" "MTBrownianGeneratorFactory *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MTBrownianGeneratorFactory > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MTBrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< MTBrownianGeneratorFactory * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MTBrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< MTBrownianGeneratorFactory * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MTBrownianGeneratorFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MTBrownianGeneratorFactory_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MTBrownianGeneratorFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SobolBrownianGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianGenerator::Ordering arg3 ;
  unsigned long arg4 ;
  SobolRsg::DirectionIntegers arg5 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SobolBrownianGenerator *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolBrownianGenerator" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SobolBrownianGenerator" "', argument " "3"" of type '" "SobolBrownianGenerator::Ordering""'");
  } 
  arg3 = static_cast< SobolBrownianGenerator::Ordering >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SobolBrownianGenerator" "', argument " "4"" of type '" "unsigned long""'");
  } 
  arg4 = static_cast< unsigned long >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SobolBrownianGenerator" "', argument " "5"" of type '" "SobolRsg::DirectionIntegers""'");
  } 
  arg5 = static_cast< SobolRsg::DirectionIntegers >(val5);
  {
    try {
      result = (SobolBrownianGenerator *)new SobolBrownianGenerator(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SobolBrownianGenerator > *smartresult = result ? new ext::shared_ptr<  SobolBrownianGenerator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGenerator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolBrownianGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianGenerator::Ordering arg3 ;
  unsigned long arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned long val4 ;
  int ecode4 = 0 ;
  SobolBrownianGenerator *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolBrownianGenerator" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SobolBrownianGenerator" "', argument " "3"" of type '" "SobolBrownianGenerator::Ordering""'");
  } 
  arg3 = static_cast< SobolBrownianGenerator::Ordering >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_long(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SobolBrownianGenerator" "', argument " "4"" of type '" "unsigned long""'");
  } 
  arg4 = static_cast< unsigned long >(val4);
  {
    try {
      result = (SobolBrownianGenerator *)new SobolBrownianGenerator(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SobolBrownianGenerator > *smartresult = result ? new ext::shared_ptr<  SobolBrownianGenerator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGenerator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolBrownianGenerator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  SobolBrownianGenerator::Ordering arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SobolBrownianGenerator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianGenerator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolBrownianGenerator" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SobolBrownianGenerator" "', argument " "3"" of type '" "SobolBrownianGenerator::Ordering""'");
  } 
  arg3 = static_cast< SobolBrownianGenerator::Ordering >(val3);
  {
    try {
      result = (SobolBrownianGenerator *)new SobolBrownianGenerator(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SobolBrownianGenerator > *smartresult = result ? new ext::shared_ptr<  SobolBrownianGenerator >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGenerator_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolBrownianGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SobolBrownianGenerator", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SobolBrownianGenerator__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SobolBrownianGenerator__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SobolBrownianGenerator__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SobolBrownianGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SobolBrownianGenerator::SobolBrownianGenerator(Size,Size,SobolBrownianGenerator::Ordering,unsigned long,SobolRsg::DirectionIntegers)\n"
    "    SobolBrownianGenerator::SobolBrownianGenerator(Size,Size,SobolBrownianGenerator::Ordering,unsigned long)\n"
    "    SobolBrownianGenerator::SobolBrownianGenerator(Size,Size,SobolBrownianGenerator::Ordering)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SobolBrownianGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianGenerator *arg1 = (SobolBrownianGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SobolBrownianGenerator > tempshared1 ;
  ext::shared_ptr< SobolBrownianGenerator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGenerator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SobolBrownianGenerator" "', argument " "1"" of type '" "SobolBrownianGenerator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SobolBrownianGenerator > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SobolBrownianGenerator > * >(argp1);
      arg1 = const_cast< SobolBrownianGenerator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SobolBrownianGenerator > * >(argp1);
      arg1 = const_cast< SobolBrownianGenerator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SobolBrownianGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SobolBrownianGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SobolBrownianGeneratorFactory__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolBrownianGenerator::Ordering arg1 ;
  unsigned long arg2 ;
  SobolRsg::DirectionIntegers arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SobolBrownianGeneratorFactory *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianGeneratorFactory" "', argument " "1"" of type '" "SobolBrownianGenerator::Ordering""'");
  } 
  arg1 = static_cast< SobolBrownianGenerator::Ordering >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolBrownianGeneratorFactory" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SobolBrownianGeneratorFactory" "', argument " "3"" of type '" "SobolRsg::DirectionIntegers""'");
  } 
  arg3 = static_cast< SobolRsg::DirectionIntegers >(val3);
  {
    try {
      result = (SobolBrownianGeneratorFactory *)new SobolBrownianGeneratorFactory(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SobolBrownianGeneratorFactory > *smartresult = result ? new ext::shared_ptr<  SobolBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolBrownianGeneratorFactory__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolBrownianGenerator::Ordering arg1 ;
  unsigned long arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  SobolBrownianGeneratorFactory *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianGeneratorFactory" "', argument " "1"" of type '" "SobolBrownianGenerator::Ordering""'");
  } 
  arg1 = static_cast< SobolBrownianGenerator::Ordering >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SobolBrownianGeneratorFactory" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  {
    try {
      result = (SobolBrownianGeneratorFactory *)new SobolBrownianGeneratorFactory(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SobolBrownianGeneratorFactory > *smartresult = result ? new ext::shared_ptr<  SobolBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolBrownianGeneratorFactory__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SobolBrownianGenerator::Ordering arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  SobolBrownianGeneratorFactory *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SobolBrownianGeneratorFactory" "', argument " "1"" of type '" "SobolBrownianGenerator::Ordering""'");
  } 
  arg1 = static_cast< SobolBrownianGenerator::Ordering >(val1);
  {
    try {
      result = (SobolBrownianGeneratorFactory *)new SobolBrownianGeneratorFactory(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SobolBrownianGeneratorFactory > *smartresult = result ? new ext::shared_ptr<  SobolBrownianGeneratorFactory >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SobolBrownianGeneratorFactory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SobolBrownianGeneratorFactory", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SobolBrownianGeneratorFactory__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SobolBrownianGeneratorFactory__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SobolBrownianGeneratorFactory__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SobolBrownianGeneratorFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SobolBrownianGeneratorFactory::SobolBrownianGeneratorFactory(SobolBrownianGenerator::Ordering,unsigned long,SobolRsg::DirectionIntegers)\n"
    "    SobolBrownianGeneratorFactory::SobolBrownianGeneratorFactory(SobolBrownianGenerator::Ordering,unsigned long)\n"
    "    SobolBrownianGeneratorFactory::SobolBrownianGeneratorFactory(SobolBrownianGenerator::Ordering)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SobolBrownianGeneratorFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SobolBrownianGeneratorFactory *arg1 = (SobolBrownianGeneratorFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SobolBrownianGeneratorFactory > tempshared1 ;
  ext::shared_ptr< SobolBrownianGeneratorFactory > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SobolBrownianGeneratorFactory" "', argument " "1"" of type '" "SobolBrownianGeneratorFactory *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SobolBrownianGeneratorFactory > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SobolBrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< SobolBrownianGeneratorFactory * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SobolBrownianGeneratorFactory > * >(argp1);
      arg1 = const_cast< SobolBrownianGeneratorFactory * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SobolBrownianGeneratorFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SobolBrownianGeneratorFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_EvolutionDescription__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  EvolutionDescription *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EvolutionDescription" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EvolutionDescription" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EvolutionDescription" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EvolutionDescription" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EvolutionDescription" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EvolutionDescription" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (EvolutionDescription *)new_EvolutionDescription__SWIG_0((std::vector< double,std::allocator< double > > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EvolutionDescription__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  EvolutionDescription *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EvolutionDescription" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EvolutionDescription" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EvolutionDescription" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EvolutionDescription" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (EvolutionDescription *)new_EvolutionDescription__SWIG_0((std::vector< double,std::allocator< double > > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EvolutionDescription__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  EvolutionDescription *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EvolutionDescription" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EvolutionDescription" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (EvolutionDescription *)new_EvolutionDescription__SWIG_0((std::vector< double,std::allocator< double > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EvolutionDescription(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_EvolutionDescription", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EvolutionDescription__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_EvolutionDescription__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EvolutionDescription__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_EvolutionDescription'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    EvolutionDescription::EvolutionDescription(std::vector< Time,std::allocator< Time > > const &,std::vector< Time,std::allocator< Time > > const &,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)\n"
    "    EvolutionDescription::EvolutionDescription(std::vector< Time,std::allocator< Time > > const &,std::vector< Time,std::allocator< Time > > const &)\n"
    "    EvolutionDescription::EvolutionDescription(std::vector< Time,std::allocator< Time > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_rateTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_rateTimes" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((EvolutionDescription const *)arg1)->rateTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_rateTaus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_rateTaus" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((EvolutionDescription const *)arg1)->rateTaus();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_evolutionTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_evolutionTimes" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((EvolutionDescription const *)arg1)->evolutionTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_firstAliveRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_firstAliveRate" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = EvolutionDescription_firstAliveRate((EvolutionDescription const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_relevanceRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_relevanceRates" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = EvolutionDescription_relevanceRates((EvolutionDescription const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_numberOfRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_numberOfRates" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = ((EvolutionDescription const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EvolutionDescription_numberOfSteps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvolutionDescription_numberOfSteps" "', argument " "1"" of type '" "EvolutionDescription const *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = ((EvolutionDescription const *)arg1)->numberOfSteps();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EvolutionDescription(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = (EvolutionDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EvolutionDescription" "', argument " "1"" of type '" "EvolutionDescription *""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EvolutionDescription_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_EvolutionDescription, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *EvolutionDescription_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_checkCompatibility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "checkCompatibility", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "checkCompatibility" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "checkCompatibility" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "checkCompatibility" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "checkCompatibility" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      _checkCompatibility((EvolutionDescription const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_isInTerminalMeasure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "isInTerminalMeasure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isInTerminalMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInTerminalMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isInTerminalMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInTerminalMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)_isInTerminalMeasure((EvolutionDescription const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_isInMoneyMarketPlusMeasure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isInMoneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInMoneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isInMoneyMarketPlusMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInMoneyMarketPlusMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "isInMoneyMarketPlusMeasure" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (bool)_isInMoneyMarketPlusMeasure((EvolutionDescription const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_isInMoneyMarketPlusMeasure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isInMoneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInMoneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isInMoneyMarketPlusMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInMoneyMarketPlusMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)_isInMoneyMarketPlusMeasure((EvolutionDescription const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_isInMoneyMarketPlusMeasure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "isInMoneyMarketPlusMeasure", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_isInMoneyMarketPlusMeasure__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_isInMoneyMarketPlusMeasure__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'isInMoneyMarketPlusMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    _isInMoneyMarketPlusMeasure(EvolutionDescription const &,std::vector< unsigned int,std::allocator< unsigned int > > const &,Size)\n"
    "    _isInMoneyMarketPlusMeasure(EvolutionDescription const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_isInMoneyMarketMeasure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "isInMoneyMarketMeasure", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isInMoneyMarketMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInMoneyMarketMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isInMoneyMarketMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "isInMoneyMarketMeasure" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)_isInMoneyMarketMeasure((EvolutionDescription const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_terminalMeasure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "terminalMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "terminalMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = _terminalMeasure((EvolutionDescription const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_moneyMarketPlusMeasure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "moneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "moneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "moneyMarketPlusMeasure" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = _moneyMarketPlusMeasure((EvolutionDescription const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_moneyMarketPlusMeasure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "moneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "moneyMarketPlusMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = _moneyMarketPlusMeasure((EvolutionDescription const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_moneyMarketPlusMeasure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "moneyMarketPlusMeasure", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_moneyMarketPlusMeasure__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EvolutionDescription, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_moneyMarketPlusMeasure__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'moneyMarketPlusMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    _moneyMarketPlusMeasure(EvolutionDescription const &,Size)\n"
    "    _moneyMarketPlusMeasure(EvolutionDescription const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_moneyMarketMeasure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  EvolutionDescription *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "moneyMarketMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "moneyMarketMeasure" "', argument " "1"" of type '" "EvolutionDescription const &""'"); 
  }
  arg1 = reinterpret_cast< EvolutionDescription * >(argp1);
  {
    try {
      result = _moneyMarketMeasure((EvolutionDescription const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_initialRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_initialRates" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((MarketModel const *)arg1)->initialRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_displacements(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Spread,std::allocator< Spread > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_displacements" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Spread,std::allocator< Spread > > *) &((MarketModel const *)arg1)->displacements();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_evolution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  EvolutionDescription *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_evolution" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (EvolutionDescription *) &((MarketModel const *)arg1)->evolution();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EvolutionDescription, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_numberOfRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_numberOfRates" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((MarketModel const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_numberOfFactors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_numberOfFactors" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((MarketModel const *)arg1)->numberOfFactors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_numberOfSteps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_numberOfSteps" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((MarketModel const *)arg1)->numberOfSteps();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_pseudoRoot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarketModel_pseudoRoot", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_pseudoRoot" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarketModel_pseudoRoot" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Matrix *) &((MarketModel const *)arg1)->pseudoRoot(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_covariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarketModel_covariance", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_covariance" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarketModel_covariance" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Matrix *) &((MarketModel const *)arg1)->covariance(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_totalCovariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarketModel_totalCovariance", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_totalCovariance" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarketModel_totalCovariance" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Matrix *) &((MarketModel const *)arg1)->totalCovariance(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModel_timeDependentVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel const > tempshared1 ;
  ext::shared_ptr< MarketModel const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< Volatility,std::allocator< Volatility > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "MarketModel_timeDependentVolatility", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModel_timeDependentVolatility" "', argument " "1"" of type '" "MarketModel const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MarketModel_timeDependentVolatility" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = ((MarketModel const *)arg1)->timeDependentVolatility(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MarketModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModel *arg1 = (MarketModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel > tempshared1 ;
  ext::shared_ptr< MarketModel > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketModel" "', argument " "1"" of type '" "MarketModel *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarketModel > * >(argp1);
      arg1 = const_cast< MarketModel * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarketModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_MarketModelFactory_create(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelFactory *arg1 = (MarketModelFactory *) 0 ;
  EvolutionDescription *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  ext::shared_ptr< MarketModel > result;
  
  if (!SWIG_Python_UnpackTuple(args, "MarketModelFactory_create", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarketModelFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelFactory_create" "', argument " "1"" of type '" "MarketModelFactory const *""'"); 
  }
  arg1 = reinterpret_cast< MarketModelFactory * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarketModelFactory_create" "', argument " "2"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarketModelFactory_create" "', argument " "2"" of type '" "EvolutionDescription const &""'"); 
  }
  arg2 = reinterpret_cast< EvolutionDescription * >(argp2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MarketModelFactory_create" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = ((MarketModelFactory const *)arg1)->create((EvolutionDescription const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  MarketModel > *smartresult = result ? new ext::shared_ptr<  MarketModel >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MarketModelFactory(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelFactory *arg1 = (MarketModelFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MarketModelFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketModelFactory" "', argument " "1"" of type '" "MarketModelFactory *""'"); 
  }
  arg1 = reinterpret_cast< MarketModelFactory * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarketModelFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MarketModelFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_PiecewiseConstantCorrelation_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > tempshared1 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConstantCorrelation_times" "', argument " "1"" of type '" "PiecewiseConstantCorrelation const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseConstantCorrelation const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConstantCorrelation_rateTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > tempshared1 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConstantCorrelation_rateTimes" "', argument " "1"" of type '" "PiecewiseConstantCorrelation const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((PiecewiseConstantCorrelation const *)arg1)->rateTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConstantCorrelation_correlations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > tempshared1 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Matrix,std::allocator< Matrix > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConstantCorrelation_correlations" "', argument " "1"" of type '" "PiecewiseConstantCorrelation const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Matrix,std::allocator< Matrix > > *) &((PiecewiseConstantCorrelation const *)arg1)->correlations();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Matrix,std::allocator< Matrix > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConstantCorrelation_correlation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > tempshared1 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "PiecewiseConstantCorrelation_correlation", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConstantCorrelation_correlation" "', argument " "1"" of type '" "PiecewiseConstantCorrelation const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PiecewiseConstantCorrelation_correlation" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Matrix *) &((PiecewiseConstantCorrelation const *)arg1)->correlation(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PiecewiseConstantCorrelation_numberOfRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > tempshared1 ;
  ext::shared_ptr< PiecewiseConstantCorrelation const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PiecewiseConstantCorrelation_numberOfRates" "', argument " "1"" of type '" "PiecewiseConstantCorrelation const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((PiecewiseConstantCorrelation const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PiecewiseConstantCorrelation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PiecewiseConstantCorrelation *arg1 = (PiecewiseConstantCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > tempshared1 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PiecewiseConstantCorrelation" "', argument " "1"" of type '" "PiecewiseConstantCorrelation *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  PiecewiseConstantCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  PiecewiseConstantCorrelation > * >(argp1);
      arg1 = const_cast< PiecewiseConstantCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PiecewiseConstantCorrelation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExponentialForwardCorrelation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  std::vector< Time,std::allocator< Time > > arg5 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialForwardCorrelation" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExponentialForwardCorrelation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialForwardCorrelation" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ExponentialForwardCorrelation" "', argument " "5"" of type '" "std::vector< Time,std::allocator< Time > >""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialForwardCorrelation > *smartresult = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialForwardCorrelation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialForwardCorrelation" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExponentialForwardCorrelation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExponentialForwardCorrelation" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialForwardCorrelation > *smartresult = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialForwardCorrelation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Real arg2 ;
  Real arg3 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialForwardCorrelation" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExponentialForwardCorrelation" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialForwardCorrelation > *smartresult = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialForwardCorrelation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  Real arg2 ;
  int res1 = SWIG_OLDOBJ ;
  double val2 ;
  int ecode2 = 0 ;
  ExponentialForwardCorrelation *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExponentialForwardCorrelation" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time,std::allocator< Time > > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialForwardCorrelation > *smartresult = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialForwardCorrelation__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  ExponentialForwardCorrelation *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExponentialForwardCorrelation" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (ExponentialForwardCorrelation *)new ExponentialForwardCorrelation((std::vector< Time,std::allocator< Time > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ExponentialForwardCorrelation > *smartresult = result ? new ext::shared_ptr<  ExponentialForwardCorrelation >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExponentialForwardCorrelation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ExponentialForwardCorrelation", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExponentialForwardCorrelation__SWIG_4(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExponentialForwardCorrelation__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ExponentialForwardCorrelation__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ExponentialForwardCorrelation__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ExponentialForwardCorrelation__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ExponentialForwardCorrelation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    ExponentialForwardCorrelation::ExponentialForwardCorrelation(std::vector< Time,std::allocator< Time > > const &,Real,Real,Real,std::vector< Time,std::allocator< Time > >)\n"
    "    ExponentialForwardCorrelation::ExponentialForwardCorrelation(std::vector< Time,std::allocator< Time > > const &,Real,Real,Real)\n"
    "    ExponentialForwardCorrelation::ExponentialForwardCorrelation(std::vector< Time,std::allocator< Time > > const &,Real,Real)\n"
    "    ExponentialForwardCorrelation::ExponentialForwardCorrelation(std::vector< Time,std::allocator< Time > > const &,Real)\n"
    "    ExponentialForwardCorrelation::ExponentialForwardCorrelation(std::vector< Time,std::allocator< Time > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExponentialForwardCorrelation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ExponentialForwardCorrelation *arg1 = (ExponentialForwardCorrelation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ExponentialForwardCorrelation > tempshared1 ;
  ext::shared_ptr< ExponentialForwardCorrelation > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExponentialForwardCorrelation" "', argument " "1"" of type '" "ExponentialForwardCorrelation *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ExponentialForwardCorrelation > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ExponentialForwardCorrelation > * >(argp1);
      arg1 = const_cast< ExponentialForwardCorrelation * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ExponentialForwardCorrelation > * >(argp1);
      arg1 = const_cast< ExponentialForwardCorrelation * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExponentialForwardCorrelation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ExponentialForwardCorrelation_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ExponentialForwardCorrelation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CurveState_numberOfRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_numberOfRates" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  {
    try {
      result = ((CurveState const *)arg1)->numberOfRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_rateTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_rateTimes" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((CurveState const *)arg1)->rateTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_rateTaus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_rateTaus" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((CurveState const *)arg1)->rateTaus();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_discountRatio(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_discountRatio", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_discountRatio" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_discountRatio" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CurveState_discountRatio" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Real)((CurveState const *)arg1)->discountRatio(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_forwardRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_forwardRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_forwardRate" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_forwardRate" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Rate)((CurveState const *)arg1)->forwardRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_coterminalSwapAnnuity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_coterminalSwapAnnuity", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_coterminalSwapAnnuity" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_coterminalSwapAnnuity" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CurveState_coterminalSwapAnnuity" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Rate)((CurveState const *)arg1)->coterminalSwapAnnuity(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_coterminalSwapRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_coterminalSwapRate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_coterminalSwapRate" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_coterminalSwapRate" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Rate)((CurveState const *)arg1)->coterminalSwapRate(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_cmSwapAnnuity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_cmSwapAnnuity", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_cmSwapAnnuity" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_cmSwapAnnuity" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CurveState_cmSwapAnnuity" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CurveState_cmSwapAnnuity" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (Rate)((CurveState const *)arg1)->cmSwapAnnuity(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_cmSwapRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_cmSwapRate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_cmSwapRate" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_cmSwapRate" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CurveState_cmSwapRate" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Rate)((CurveState const *)arg1)->cmSwapRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_forwardRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_forwardRates" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((CurveState const *)arg1)->forwardRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_coterminalSwapRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_coterminalSwapRates" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((CurveState const *)arg1)->coterminalSwapRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_cmSwapRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_cmSwapRates", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_cmSwapRates" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_cmSwapRates" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((CurveState const *)arg1)->cmSwapRates(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CurveState_swapRate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Rate result;
  
  if (!SWIG_Python_UnpackTuple(args, "CurveState_swapRate", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveState_swapRate" "', argument " "1"" of type '" "CurveState const *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurveState_swapRate" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CurveState_swapRate" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (Rate)((CurveState const *)arg1)->swapRate(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CurveState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CurveState *arg1 = (CurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CurveState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurveState" "', argument " "1"" of type '" "CurveState *""'"); 
  }
  arg1 = reinterpret_cast< CurveState * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CurveState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_CurveState, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LMMCurveState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  LMMCurveState *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LMMCurveState" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LMMCurveState" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (LMMCurveState *)new LMMCurveState((std::vector< Time,std::allocator< Time > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LMMCurveState, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMCurveState_setOnForwardRates__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMCurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMCurveState_setOnForwardRates" "', argument " "1"" of type '" "LMMCurveState *""'"); 
  }
  arg1 = reinterpret_cast< LMMCurveState * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMCurveState_setOnForwardRates" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMCurveState_setOnForwardRates" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LMMCurveState_setOnForwardRates" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      (arg1)->setOnForwardRates((std::vector< Rate,std::allocator< Rate > > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMCurveState_setOnForwardRates__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMCurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMCurveState_setOnForwardRates" "', argument " "1"" of type '" "LMMCurveState *""'"); 
  }
  arg1 = reinterpret_cast< LMMCurveState * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMCurveState_setOnForwardRates" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMCurveState_setOnForwardRates" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->setOnForwardRates((std::vector< Rate,std::allocator< Rate > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMCurveState_setOnForwardRates(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LMMCurveState_setOnForwardRates", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMCurveState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LMMCurveState_setOnForwardRates__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMCurveState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LMMCurveState_setOnForwardRates__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LMMCurveState_setOnForwardRates'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LMMCurveState::setOnForwardRates(std::vector< Rate,std::allocator< Rate > > const &,Size)\n"
    "    LMMCurveState::setOnForwardRates(std::vector< Rate,std::allocator< Rate > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LMMCurveState_setOnDiscountRatios__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMCurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "1"" of type '" "LMMCurveState *""'"); 
  }
  arg1 = reinterpret_cast< LMMCurveState * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      (arg1)->setOnDiscountRatios((std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMCurveState_setOnDiscountRatios__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  std::vector< DiscountFactor,std::allocator< DiscountFactor > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMCurveState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "1"" of type '" "LMMCurveState *""'"); 
  }
  arg1 = reinterpret_cast< LMMCurveState * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMCurveState_setOnDiscountRatios" "', argument " "2"" of type '" "std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->setOnDiscountRatios((std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMCurveState_setOnDiscountRatios(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LMMCurveState_setOnDiscountRatios", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMCurveState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LMMCurveState_setOnDiscountRatios__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMCurveState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LMMCurveState_setOnDiscountRatios__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LMMCurveState_setOnDiscountRatios'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LMMCurveState::setOnDiscountRatios(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &,Size)\n"
    "    LMMCurveState::setOnDiscountRatios(std::vector< DiscountFactor,std::allocator< DiscountFactor > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LMMCurveState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LMMCurveState *arg1 = (LMMCurveState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMCurveState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LMMCurveState" "', argument " "1"" of type '" "LMMCurveState *""'"); 
  }
  arg1 = reinterpret_cast< LMMCurveState * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LMMCurveState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LMMCurveState, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LMMCurveState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LMMDriftCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Matrix *arg1 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg2 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg3 = 0 ;
  Size arg4 ;
  Size arg5 ;
  Matrix temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  LMMDriftCalculator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_LMMDriftCalculator", 5, 5, swig_obj)) SWIG_fail;
  {
    if (PyTuple_Check(swig_obj[0]) || PyList_Check(swig_obj[0])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[0]) ?
      PyTuple_Size(swig_obj[0]) :
        PyList_Size(swig_obj[0]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[0],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp1 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[0],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp1[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp1[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LMMDriftCalculator" "', argument " "1"" of type '" "Matrix const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LMMDriftCalculator" "', argument " "1"" of type '" "Matrix const &""'"); 
      }
      arg1 = reinterpret_cast< Matrix * >(argp1);
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LMMDriftCalculator" "', argument " "2"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LMMDriftCalculator" "', argument " "2"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LMMDriftCalculator" "', argument " "3"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LMMDriftCalculator" "', argument " "3"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LMMDriftCalculator" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LMMDriftCalculator" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (LMMDriftCalculator *)new LMMDriftCalculator((Matrix const &)*arg1,(std::vector< Spread,std::allocator< Spread > > const &)*arg2,(std::vector< Time,std::allocator< Time > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LMMDriftCalculator, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_compute__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  LMMCurveState *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMDriftCalculator_compute" "', argument " "1"" of type '" "LMMDriftCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_LMMCurveState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMDriftCalculator_compute" "', argument " "2"" of type '" "LMMCurveState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_compute" "', argument " "2"" of type '" "LMMCurveState const &""'"); 
  }
  arg2 = reinterpret_cast< LMMCurveState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LMMDriftCalculator_compute" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_compute" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp3);
  {
    try {
      ((LMMDriftCalculator const *)arg1)->compute((LMMCurveState const &)*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_compute__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMDriftCalculator_compute" "', argument " "1"" of type '" "LMMDriftCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMDriftCalculator_compute" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_compute" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LMMDriftCalculator_compute" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_compute" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp3);
  {
    try {
      ((LMMDriftCalculator const *)arg1)->compute((std::vector< Rate,std::allocator< Rate > > const &)*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_compute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LMMDriftCalculator_compute", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMDriftCalculator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_LMMCurveState, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LMMDriftCalculator_compute__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMDriftCalculator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LMMDriftCalculator_compute__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LMMDriftCalculator_compute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LMMDriftCalculator::compute(LMMCurveState const &,std::vector< Real,std::allocator< Real > > &) const\n"
    "    LMMDriftCalculator::compute(std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_computePlain__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  LMMCurveState *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMDriftCalculator_computePlain" "', argument " "1"" of type '" "LMMDriftCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_LMMCurveState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMDriftCalculator_computePlain" "', argument " "2"" of type '" "LMMCurveState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computePlain" "', argument " "2"" of type '" "LMMCurveState const &""'"); 
  }
  arg2 = reinterpret_cast< LMMCurveState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LMMDriftCalculator_computePlain" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computePlain" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp3);
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computePlain((LMMCurveState const &)*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_computePlain__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMDriftCalculator_computePlain" "', argument " "1"" of type '" "LMMDriftCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMDriftCalculator_computePlain" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computePlain" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LMMDriftCalculator_computePlain" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computePlain" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp3);
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computePlain((std::vector< Rate,std::allocator< Rate > > const &)*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_computePlain(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LMMDriftCalculator_computePlain", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMDriftCalculator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_LMMCurveState, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LMMDriftCalculator_computePlain__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMDriftCalculator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LMMDriftCalculator_computePlain__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LMMDriftCalculator_computePlain'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LMMDriftCalculator::computePlain(LMMCurveState const &,std::vector< Real,std::allocator< Real > > &) const\n"
    "    LMMDriftCalculator::computePlain(std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_computeReduced__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  LMMCurveState *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMDriftCalculator_computeReduced" "', argument " "1"" of type '" "LMMDriftCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_LMMCurveState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMDriftCalculator_computeReduced" "', argument " "2"" of type '" "LMMCurveState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computeReduced" "', argument " "2"" of type '" "LMMCurveState const &""'"); 
  }
  arg2 = reinterpret_cast< LMMCurveState * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LMMDriftCalculator_computeReduced" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computeReduced" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp3);
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computeReduced((LMMCurveState const &)*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_computeReduced__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LMMDriftCalculator_computeReduced" "', argument " "1"" of type '" "LMMDriftCalculator const *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LMMDriftCalculator_computeReduced" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computeReduced" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LMMDriftCalculator_computeReduced" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LMMDriftCalculator_computeReduced" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Real,std::allocator< Real > > * >(argp3);
  {
    try {
      ((LMMDriftCalculator const *)arg1)->computeReduced((std::vector< Rate,std::allocator< Rate > > const &)*arg2,*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LMMDriftCalculator_computeReduced(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "LMMDriftCalculator_computeReduced", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMDriftCalculator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_LMMCurveState, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LMMDriftCalculator_computeReduced__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_LMMDriftCalculator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LMMDriftCalculator_computeReduced__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LMMDriftCalculator_computeReduced'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LMMDriftCalculator::computeReduced(LMMCurveState const &,std::vector< Real,std::allocator< Real > > &) const\n"
    "    LMMDriftCalculator::computeReduced(std::vector< Rate,std::allocator< Rate > > const &,std::vector< Real,std::allocator< Real > > &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LMMDriftCalculator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LMMDriftCalculator *arg1 = (LMMDriftCalculator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_LMMDriftCalculator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LMMDriftCalculator" "', argument " "1"" of type '" "LMMDriftCalculator *""'"); 
  }
  arg1 = reinterpret_cast< LMMDriftCalculator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LMMDriftCalculator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_LMMDriftCalculator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LMMDriftCalculator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_MarketModelEvolver_numeraires(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver const > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelEvolver_numeraires" "', argument " "1"" of type '" "MarketModelEvolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = MarketModelEvolver_numeraires((MarketModelEvolver const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModelEvolver_startNewPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelEvolver_startNewPath" "', argument " "1"" of type '" "MarketModelEvolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->startNewPath();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModelEvolver_advanceStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelEvolver_advanceStep" "', argument " "1"" of type '" "MarketModelEvolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->advanceStep();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModelEvolver_currentStep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver const > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelEvolver_currentStep" "', argument " "1"" of type '" "MarketModelEvolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((MarketModelEvolver const *)arg1)->currentStep();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModelEvolver_currentState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver const > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  CurveState *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelEvolver_currentState" "', argument " "1"" of type '" "MarketModelEvolver const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (CurveState *) &((MarketModelEvolver const *)arg1)->currentState();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurveState, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MarketModelEvolver_setInitialState(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  CurveState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "MarketModelEvolver_setInitialState", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MarketModelEvolver_setInitialState" "', argument " "1"" of type '" "MarketModelEvolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_CurveState,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MarketModelEvolver_setInitialState" "', argument " "2"" of type '" "CurveState const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MarketModelEvolver_setInitialState" "', argument " "2"" of type '" "CurveState const &""'"); 
  }
  arg2 = reinterpret_cast< CurveState * >(argp2);
  {
    try {
      (arg1)->setInitialState((CurveState const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MarketModelEvolver(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MarketModelEvolver *arg1 = (MarketModelEvolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModelEvolver > tempshared1 ;
  ext::shared_ptr< MarketModelEvolver > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketModelEvolver" "', argument " "1"" of type '" "MarketModelEvolver *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  MarketModelEvolver > * >(argp1);
      arg1 = const_cast< MarketModelEvolver * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarketModelEvolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_MarketModelEvolver_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LogNormalFwdRateIpc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< MarketModel > *arg1 = 0 ;
  BrownianGeneratorFactory *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory const > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  LogNormalFwdRateIpc *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalFwdRateIpc" "', argument " "1"" of type '" "ext::shared_ptr< MarketModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< MarketModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< MarketModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalFwdRateIpc" "', argument " "2"" of type '" "BrownianGeneratorFactory const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalFwdRateIpc" "', argument " "2"" of type '" "BrownianGeneratorFactory const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp2);
      arg2 = const_cast< BrownianGeneratorFactory * >(tempshared2.get());
    } else {
      arg2 = const_cast< BrownianGeneratorFactory * >(reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp2)->get());
    }
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalFwdRateIpc" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalFwdRateIpc" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogNormalFwdRateIpc" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (LogNormalFwdRateIpc *)new_LogNormalFwdRateIpc__SWIG_0((ext::shared_ptr< MarketModel > const &)*arg1,(BrownianGeneratorFactory const &)*arg2,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3,SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalFwdRateIpc > *smartresult = result ? new ext::shared_ptr<  LogNormalFwdRateIpc >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalFwdRateIpc_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalFwdRateIpc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< MarketModel > *arg1 = 0 ;
  BrownianGeneratorFactory *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< MarketModel > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory const > tempshared2 ;
  int res3 = SWIG_OLDOBJ ;
  LogNormalFwdRateIpc *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogNormalFwdRateIpc" "', argument " "1"" of type '" "ext::shared_ptr< MarketModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< MarketModel > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< MarketModel > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< MarketModel > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogNormalFwdRateIpc" "', argument " "2"" of type '" "BrownianGeneratorFactory const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalFwdRateIpc" "', argument " "2"" of type '" "BrownianGeneratorFactory const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp2);
      arg2 = const_cast< BrownianGeneratorFactory * >(tempshared2.get());
    } else {
      arg2 = const_cast< BrownianGeneratorFactory * >(reinterpret_cast< ext::shared_ptr< const BrownianGeneratorFactory > * >(argp2)->get());
    }
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogNormalFwdRateIpc" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogNormalFwdRateIpc" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (LogNormalFwdRateIpc *)new_LogNormalFwdRateIpc__SWIG_0((ext::shared_ptr< MarketModel > const &)*arg1,(BrownianGeneratorFactory const &)*arg2,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LogNormalFwdRateIpc > *smartresult = result ? new ext::shared_ptr<  LogNormalFwdRateIpc >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LogNormalFwdRateIpc_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogNormalFwdRateIpc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LogNormalFwdRateIpc", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LogNormalFwdRateIpc__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_MarketModel_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LogNormalFwdRateIpc__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LogNormalFwdRateIpc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    LogNormalFwdRateIpc::LogNormalFwdRateIpc(ext::shared_ptr< MarketModel > const &,BrownianGeneratorFactory const &,std::vector< unsigned int,std::allocator< unsigned int > > const &,Size)\n"
    "    LogNormalFwdRateIpc::LogNormalFwdRateIpc(ext::shared_ptr< MarketModel > const &,BrownianGeneratorFactory const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LogNormalFwdRateIpc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  LogNormalFwdRateIpc *arg1 = (LogNormalFwdRateIpc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< LogNormalFwdRateIpc > tempshared1 ;
  ext::shared_ptr< LogNormalFwdRateIpc > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LogNormalFwdRateIpc_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNormalFwdRateIpc" "', argument " "1"" of type '" "LogNormalFwdRateIpc *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  LogNormalFwdRateIpc > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  LogNormalFwdRateIpc > * >(argp1);
      arg1 = const_cast< LogNormalFwdRateIpc * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  LogNormalFwdRateIpc > * >(argp1);
      arg1 = const_cast< LogNormalFwdRateIpc * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogNormalFwdRateIpc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_LogNormalFwdRateIpc_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogNormalFwdRateIpc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AbcdVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  std::vector< Real,std::allocator< Real > > *arg5 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > *arg6 = 0 ;
  EvolutionDescription *arg7 = 0 ;
  Size arg8 ;
  std::vector< Rate,std::allocator< Rate > > *arg9 = 0 ;
  std::vector< Spread,std::allocator< Spread > > *arg10 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 ;
  int res6 = 0 ;
  ext::shared_ptr< PiecewiseConstantCorrelation > tempshared6 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  int res9 = SWIG_OLDOBJ ;
  int res10 = SWIG_OLDOBJ ;
  PyObject *swig_obj[10] ;
  AbcdVol *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_AbcdVol", 10, 10, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdVol" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdVol" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AbcdVol" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AbcdVol" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_AbcdVol" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AbcdVol" "', argument " "5"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    int newmem = 0;
    res6 = SWIG_ConvertPtrAndOwn(swig_obj[5], &argp6, SWIGTYPE_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t,  0 , &newmem);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_AbcdVol" "', argument " "6"" of type '" "ext::shared_ptr< PiecewiseConstantCorrelation > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp6) tempshared6 = *reinterpret_cast< ext::shared_ptr< PiecewiseConstantCorrelation > * >(argp6);
      delete reinterpret_cast< ext::shared_ptr< PiecewiseConstantCorrelation > * >(argp6);
      arg6 = &tempshared6;
    } else {
      arg6 = (argp6) ? reinterpret_cast< ext::shared_ptr< PiecewiseConstantCorrelation > * >(argp6) : &tempshared6;
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_EvolutionDescription,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_AbcdVol" "', argument " "7"" of type '" "EvolutionDescription const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AbcdVol" "', argument " "7"" of type '" "EvolutionDescription const &""'"); 
  }
  arg7 = reinterpret_cast< EvolutionDescription * >(argp7);
  ecode8 = SWIG_AsVal_size_t(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_AbcdVol" "', argument " "8"" of type '" "Size""'");
  } 
  arg8 = static_cast< Size >(val8);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res9 = swig::asptr(swig_obj[8], &ptr);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_AbcdVol" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AbcdVol" "', argument " "9"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg9 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res10 = swig::asptr(swig_obj[9], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_AbcdVol" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AbcdVol" "', argument " "10"" of type '" "std::vector< Spread,std::allocator< Spread > > const &""'"); 
    }
    arg10 = ptr;
  }
  {
    try {
      result = (AbcdVol *)new AbcdVol(arg1,arg2,arg3,arg4,(std::vector< Real,std::allocator< Real > > const &)*arg5,(ext::shared_ptr< PiecewiseConstantCorrelation > const &)*arg6,(EvolutionDescription const &)*arg7,arg8,(std::vector< Rate,std::allocator< Rate > > const &)*arg9,(std::vector< Spread,std::allocator< Spread > > const &)*arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AbcdVol > *smartresult = result ? new ext::shared_ptr<  AbcdVol >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AbcdVol_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res9)) delete arg9;
  if (SWIG_IsNewObj(res10)) delete arg10;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AbcdVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdVol *arg1 = (AbcdVol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AbcdVol > tempshared1 ;
  ext::shared_ptr< AbcdVol > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AbcdVol_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbcdVol" "', argument " "1"" of type '" "AbcdVol *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AbcdVol > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AbcdVol > * >(argp1);
      arg1 = const_cast< AbcdVol * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AbcdVol > * >(argp1);
      arg1 = const_cast< AbcdVol * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AbcdVol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AbcdVol_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AbcdVol_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AbcdMathFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  AbcdMathFunction *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdMathFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdMathFunction" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AbcdMathFunction" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AbcdMathFunction" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdMathFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  AbcdMathFunction *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdMathFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdMathFunction" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AbcdMathFunction" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdMathFunction__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  AbcdMathFunction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdMathFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdMathFunction" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdMathFunction__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  AbcdMathFunction *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdMathFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdMathFunction__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  AbcdMathFunction *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdMathFunction__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Real,std::allocator< Real > > arg1 ;
  AbcdMathFunction *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_AbcdMathFunction" "', argument " "1"" of type '" "std::vector< Real,std::allocator< Real > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (AbcdMathFunction *)new AbcdMathFunction(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdMathFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AbcdMathFunction", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_AbcdMathFunction__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_AbcdMathFunction__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AbcdMathFunction__SWIG_5(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AbcdMathFunction__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AbcdMathFunction__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_AbcdMathFunction__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AbcdMathFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AbcdMathFunction::AbcdMathFunction(Real,Real,Real,Real)\n"
    "    AbcdMathFunction::AbcdMathFunction(Real,Real,Real)\n"
    "    AbcdMathFunction::AbcdMathFunction(Real,Real)\n"
    "    AbcdMathFunction::AbcdMathFunction(Real)\n"
    "    AbcdMathFunction::AbcdMathFunction()\n"
    "    AbcdMathFunction::AbcdMathFunction(std::vector< Real,std::allocator< Real > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction___call__" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction___call__" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->operator ()(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_maximumLocation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_maximumLocation" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Time)((AbcdMathFunction const *)arg1)->maximumLocation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_maximumValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_maximumValue" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->maximumValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_longTermValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_longTermValue" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->longTermValue();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_derivative(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction_derivative", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_derivative" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction_derivative" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->derivative(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_primitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction_primitive", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_primitive" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction_primitive" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->primitive(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_definiteIntegral(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction_definiteIntegral", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_definiteIntegral" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction_definiteIntegral" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdMathFunction_definiteIntegral" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->definiteIntegral(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_a(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_a" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->a();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_b(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_b" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->b();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_c(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_c" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->c();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_d(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_d" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdMathFunction const *)arg1)->d();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_coefficients(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_coefficients" "', argument " "1"" of type '" "AbcdMathFunction *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &(arg1)->coefficients();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_derivativeCoefficients(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_derivativeCoefficients" "', argument " "1"" of type '" "AbcdMathFunction *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &(arg1)->derivativeCoefficients();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_definiteIntegralCoefficients(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction_definiteIntegralCoefficients", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_definiteIntegralCoefficients" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction_definiteIntegralCoefficients" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdMathFunction_definiteIntegralCoefficients" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((AbcdMathFunction const *)arg1)->definiteIntegralCoefficients(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_definiteDerivativeCoefficients(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction_definiteDerivativeCoefficients", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdMathFunction_definiteDerivativeCoefficients" "', argument " "1"" of type '" "AbcdMathFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction_definiteDerivativeCoefficients" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdMathFunction_definiteDerivativeCoefficients" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = ((AbcdMathFunction const *)arg1)->definiteDerivativeCoefficients(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdMathFunction_validate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdMathFunction_validate", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AbcdMathFunction_validate" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdMathFunction_validate" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdMathFunction_validate" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdMathFunction_validate" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      AbcdMathFunction::validate(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AbcdMathFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdMathFunction *arg1 = (AbcdMathFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdMathFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbcdMathFunction" "', argument " "1"" of type '" "AbcdMathFunction *""'"); 
  }
  arg1 = reinterpret_cast< AbcdMathFunction * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AbcdMathFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AbcdMathFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AbcdMathFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AbcdFunction__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  AbcdFunction *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdFunction" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AbcdFunction" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_AbcdFunction" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(arg1,arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdFunction__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  AbcdFunction *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdFunction" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AbcdFunction" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdFunction__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  AbcdFunction *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AbcdFunction" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdFunction__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  AbcdFunction *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AbcdFunction" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (AbcdFunction *)new AbcdFunction(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdFunction__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  AbcdFunction *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (AbcdFunction *)new AbcdFunction();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AbcdFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AbcdFunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_AbcdFunction", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_AbcdFunction__SWIG_4(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_AbcdFunction__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AbcdFunction__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_AbcdFunction__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_AbcdFunction__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_AbcdFunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AbcdFunction::AbcdFunction(Real,Real,Real,Real)\n"
    "    AbcdFunction::AbcdFunction(Real,Real,Real)\n"
    "    AbcdFunction::AbcdFunction(Real,Real)\n"
    "    AbcdFunction::AbcdFunction(Real)\n"
    "    AbcdFunction::AbcdFunction()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_maximumVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_maximumVolatility" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->maximumVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_shortTermVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_shortTermVolatility" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->shortTermVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_longTermVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_longTermVolatility" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->longTermVolatility();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_covariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Real result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_covariance" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_covariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_covariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdFunction_covariance" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->covariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_covariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  Time arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Real result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_covariance" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_covariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_covariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdFunction_covariance" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AbcdFunction_covariance" "', argument " "5"" of type '" "Time""'");
  } 
  arg5 = static_cast< Time >(val5);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->covariance(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_covariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "AbcdFunction_covariance", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AbcdFunction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_AbcdFunction_covariance__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AbcdFunction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_AbcdFunction_covariance__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbcdFunction_covariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AbcdFunction::covariance(Time,Time,Time) const\n"
    "    AbcdFunction::covariance(Time,Time,Time,Time) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_volatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdFunction_volatility", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_volatility" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_volatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdFunction_volatility" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdFunction_variance", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_variance" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_variance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_variance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdFunction_variance" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->variance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_instantaneousVolatility(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdFunction_instantaneousVolatility", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_instantaneousVolatility" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_instantaneousVolatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_instantaneousVolatility" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->instantaneousVolatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_instantaneousVariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdFunction_instantaneousVariance", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_instantaneousVariance" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_instantaneousVariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_instantaneousVariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->instantaneousVariance(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_instantaneousCovariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdFunction_instantaneousCovariance", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_instantaneousCovariance" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_instantaneousCovariance" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_instantaneousCovariance" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdFunction_instantaneousCovariance" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->instantaneousCovariance(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AbcdFunction_primitive(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  Time arg2 ;
  Time arg3 ;
  Time arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "AbcdFunction_primitive", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbcdFunction_primitive" "', argument " "1"" of type '" "AbcdFunction const *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbcdFunction_primitive" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbcdFunction_primitive" "', argument " "3"" of type '" "Time""'");
  } 
  arg3 = static_cast< Time >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbcdFunction_primitive" "', argument " "4"" of type '" "Time""'");
  } 
  arg4 = static_cast< Time >(val4);
  {
    try {
      result = (Real)((AbcdFunction const *)arg1)->primitive(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AbcdFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AbcdFunction *arg1 = (AbcdFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AbcdFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbcdFunction" "', argument " "1"" of type '" "AbcdFunction *""'"); 
  }
  arg1 = reinterpret_cast< AbcdFunction * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AbcdFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AbcdFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AbcdFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ContinuousFloatingLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< TypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< TypePayoff > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  ContinuousFloatingLookbackOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ContinuousFloatingLookbackOption", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContinuousFloatingLookbackOption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_TypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContinuousFloatingLookbackOption" "', argument " "2"" of type '" "ext::shared_ptr< TypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< TypePayoff > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< TypePayoff > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< TypePayoff > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ContinuousFloatingLookbackOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (ContinuousFloatingLookbackOption *)new ContinuousFloatingLookbackOption(arg1,(ext::shared_ptr< TypePayoff > const &)*arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ContinuousFloatingLookbackOption > *smartresult = result ? new ext::shared_ptr<  ContinuousFloatingLookbackOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ContinuousFloatingLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ContinuousFloatingLookbackOption *arg1 = (ContinuousFloatingLookbackOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ContinuousFloatingLookbackOption > tempshared1 ;
  ext::shared_ptr< ContinuousFloatingLookbackOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContinuousFloatingLookbackOption" "', argument " "1"" of type '" "ContinuousFloatingLookbackOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ContinuousFloatingLookbackOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ContinuousFloatingLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousFloatingLookbackOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ContinuousFloatingLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousFloatingLookbackOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContinuousFloatingLookbackOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ContinuousFloatingLookbackOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ContinuousFixedLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  ext::shared_ptr< StrikedTypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  ContinuousFixedLookbackOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ContinuousFixedLookbackOption", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContinuousFixedLookbackOption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContinuousFixedLookbackOption" "', argument " "2"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ContinuousFixedLookbackOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (ContinuousFixedLookbackOption *)new ContinuousFixedLookbackOption(arg1,(ext::shared_ptr< StrikedTypePayoff > const &)*arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ContinuousFixedLookbackOption > *smartresult = result ? new ext::shared_ptr<  ContinuousFixedLookbackOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ContinuousFixedLookbackOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ContinuousFixedLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ContinuousFixedLookbackOption *arg1 = (ContinuousFixedLookbackOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ContinuousFixedLookbackOption > tempshared1 ;
  ext::shared_ptr< ContinuousFixedLookbackOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ContinuousFixedLookbackOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContinuousFixedLookbackOption" "', argument " "1"" of type '" "ContinuousFixedLookbackOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ContinuousFixedLookbackOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ContinuousFixedLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousFixedLookbackOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ContinuousFixedLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousFixedLookbackOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContinuousFixedLookbackOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ContinuousFixedLookbackOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ContinuousFixedLookbackOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ContinuousPartialFloatingLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Date arg3 ;
  ext::shared_ptr< TypePayoff > *arg4 = 0 ;
  ext::shared_ptr< Exercise > *arg5 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  ext::shared_ptr< TypePayoff > tempshared4 ;
  void *argp5 ;
  int res5 = 0 ;
  ext::shared_ptr< Exercise > tempshared5 ;
  PyObject *swig_obj[5] ;
  ContinuousPartialFloatingLookbackOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ContinuousPartialFloatingLookbackOption", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContinuousPartialFloatingLookbackOption" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContinuousPartialFloatingLookbackOption" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ContinuousPartialFloatingLookbackOption" "', argument " "3"" of type '" "Date""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContinuousPartialFloatingLookbackOption" "', argument " "3"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_ext__shared_ptrT_TypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ContinuousPartialFloatingLookbackOption" "', argument " "4"" of type '" "ext::shared_ptr< TypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< ext::shared_ptr< TypePayoff > * >(argp4);
      delete reinterpret_cast< ext::shared_ptr< TypePayoff > * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< ext::shared_ptr< TypePayoff > * >(argp4) : &tempshared4;
    }
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ContinuousPartialFloatingLookbackOption" "', argument " "5"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp5) tempshared5 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5);
      arg5 = &tempshared5;
    } else {
      arg5 = (argp5) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp5) : &tempshared5;
    }
  }
  {
    try {
      result = (ContinuousPartialFloatingLookbackOption *)new ContinuousPartialFloatingLookbackOption(arg1,arg2,arg3,(ext::shared_ptr< TypePayoff > const &)*arg4,(ext::shared_ptr< Exercise > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ContinuousPartialFloatingLookbackOption > *smartresult = result ? new ext::shared_ptr<  ContinuousPartialFloatingLookbackOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ContinuousPartialFloatingLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ContinuousPartialFloatingLookbackOption *arg1 = (ContinuousPartialFloatingLookbackOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ContinuousPartialFloatingLookbackOption > tempshared1 ;
  ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContinuousPartialFloatingLookbackOption" "', argument " "1"" of type '" "ContinuousPartialFloatingLookbackOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ContinuousPartialFloatingLookbackOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ContinuousPartialFloatingLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousPartialFloatingLookbackOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ContinuousPartialFloatingLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousPartialFloatingLookbackOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContinuousPartialFloatingLookbackOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ContinuousPartialFloatingLookbackOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ContinuousPartialFixedLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Date arg1 ;
  ext::shared_ptr< StrikedTypePayoff > *arg2 = 0 ;
  ext::shared_ptr< Exercise > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< StrikedTypePayoff > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< Exercise > tempshared3 ;
  PyObject *swig_obj[3] ;
  ContinuousPartialFixedLookbackOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ContinuousPartialFixedLookbackOption", 3, 3, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContinuousPartialFixedLookbackOption" "', argument " "1"" of type '" "Date""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContinuousPartialFixedLookbackOption" "', argument " "1"" of type '" "Date""'");
    } else {
      Date * temp = reinterpret_cast< Date * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_StrikedTypePayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContinuousPartialFixedLookbackOption" "', argument " "2"" of type '" "ext::shared_ptr< StrikedTypePayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< StrikedTypePayoff > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ContinuousPartialFixedLookbackOption" "', argument " "3"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (ContinuousPartialFixedLookbackOption *)new ContinuousPartialFixedLookbackOption(arg1,(ext::shared_ptr< StrikedTypePayoff > const &)*arg2,(ext::shared_ptr< Exercise > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  ContinuousPartialFixedLookbackOption > *smartresult = result ? new ext::shared_ptr<  ContinuousPartialFixedLookbackOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ContinuousPartialFixedLookbackOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ContinuousPartialFixedLookbackOption *arg1 = (ContinuousPartialFixedLookbackOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< ContinuousPartialFixedLookbackOption > tempshared1 ;
  ext::shared_ptr< ContinuousPartialFixedLookbackOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContinuousPartialFixedLookbackOption" "', argument " "1"" of type '" "ContinuousPartialFixedLookbackOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  ContinuousPartialFixedLookbackOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  ContinuousPartialFixedLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousPartialFixedLookbackOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  ContinuousPartialFixedLookbackOption > * >(argp1);
      arg1 = const_cast< ContinuousPartialFixedLookbackOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContinuousPartialFixedLookbackOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ContinuousPartialFixedLookbackOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticContinuousFloatingLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticContinuousFloatingLookbackEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousFloatingLookbackEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticContinuousFloatingLookbackEngine *)new AnalyticContinuousFloatingLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFloatingLookbackEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticContinuousFloatingLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticContinuousFloatingLookbackEngine *arg1 = (AnalyticContinuousFloatingLookbackEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticContinuousFloatingLookbackEngine > tempshared1 ;
  ext::shared_ptr< AnalyticContinuousFloatingLookbackEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFloatingLookbackEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticContinuousFloatingLookbackEngine" "', argument " "1"" of type '" "AnalyticContinuousFloatingLookbackEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousFloatingLookbackEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticContinuousFloatingLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousFloatingLookbackEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticContinuousFloatingLookbackEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFloatingLookbackEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticContinuousFloatingLookbackEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticContinuousFixedLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticContinuousFixedLookbackEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousFixedLookbackEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticContinuousFixedLookbackEngine *)new AnalyticContinuousFixedLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFixedLookbackEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticContinuousFixedLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticContinuousFixedLookbackEngine *arg1 = (AnalyticContinuousFixedLookbackEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticContinuousFixedLookbackEngine > tempshared1 ;
  ext::shared_ptr< AnalyticContinuousFixedLookbackEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFixedLookbackEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticContinuousFixedLookbackEngine" "', argument " "1"" of type '" "AnalyticContinuousFixedLookbackEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousFixedLookbackEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticContinuousFixedLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousFixedLookbackEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticContinuousFixedLookbackEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousFixedLookbackEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticContinuousFixedLookbackEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticContinuousPartialFloatingLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticContinuousPartialFloatingLookbackEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousPartialFloatingLookbackEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticContinuousPartialFloatingLookbackEngine *)new AnalyticContinuousPartialFloatingLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFloatingLookbackEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticContinuousPartialFloatingLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticContinuousPartialFloatingLookbackEngine *arg1 = (AnalyticContinuousPartialFloatingLookbackEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticContinuousPartialFloatingLookbackEngine > tempshared1 ;
  ext::shared_ptr< AnalyticContinuousPartialFloatingLookbackEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFloatingLookbackEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticContinuousPartialFloatingLookbackEngine" "', argument " "1"" of type '" "AnalyticContinuousPartialFloatingLookbackEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousPartialFloatingLookbackEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticContinuousPartialFloatingLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousPartialFloatingLookbackEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticContinuousPartialFloatingLookbackEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFloatingLookbackEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticContinuousPartialFloatingLookbackEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_AnalyticContinuousPartialFixedLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  PyObject *swig_obj[1] ;
  AnalyticContinuousPartialFixedLookbackEngine *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AnalyticContinuousPartialFixedLookbackEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (AnalyticContinuousPartialFixedLookbackEngine *)new AnalyticContinuousPartialFixedLookbackEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine > *smartresult = result ? new ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFixedLookbackEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AnalyticContinuousPartialFixedLookbackEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AnalyticContinuousPartialFixedLookbackEngine *arg1 = (AnalyticContinuousPartialFixedLookbackEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< AnalyticContinuousPartialFixedLookbackEngine > tempshared1 ;
  ext::shared_ptr< AnalyticContinuousPartialFixedLookbackEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFixedLookbackEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnalyticContinuousPartialFixedLookbackEngine" "', argument " "1"" of type '" "AnalyticContinuousPartialFixedLookbackEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousPartialFixedLookbackEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  AnalyticContinuousPartialFixedLookbackEngine > * >(argp1);
      arg1 = const_cast< AnalyticContinuousPartialFixedLookbackEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AnalyticContinuousPartialFixedLookbackEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_AnalyticContinuousPartialFixedLookbackEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *AnalyticContinuousPartialFixedLookbackEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_getCovariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Matrix *arg2 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Matrix temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Matrix result;
  
  if (!SWIG_Python_UnpackTuple(args, "getCovariance", 2, 2, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCovariance" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getCovariance" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (PyTuple_Check(swig_obj[1]) || PyList_Check(swig_obj[1])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[1]) ?
      PyTuple_Size(swig_obj[1]) :
        PyList_Size(swig_obj[1]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[1],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp2 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[1],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp2[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp2[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getCovariance" "', argument " "2"" of type '" "Matrix const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getCovariance" "', argument " "2"" of type '" "Matrix const &""'"); 
      }
      arg2 = reinterpret_cast< Matrix * >(argp2);
    }
  }
  {
    try {
      result = getCovariance((Array const &)*arg1,(Matrix const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Path___len__" "', argument " "1"" of type '" "Path const *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  {
    try {
      result = ((Path const *)arg1)->length();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Path_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Path_value" "', argument " "1"" of type '" "Path const *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Path_value" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)((Path const *)arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Path_front" "', argument " "1"" of type '" "Path const *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  {
    try {
      result = (Real)((Path const *)arg1)->front();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Path_back" "', argument " "1"" of type '" "Path const *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  {
    try {
      result = (Real)((Path const *)arg1)->back();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path_time(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "Path_time", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Path_time" "', argument " "1"" of type '" "Path const *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Path_time" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Time)((Path const *)arg1)->time(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Path___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "Path___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Path___getitem__" "', argument " "1"" of type '" "Path *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Path___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (Real)Path___getitem__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Path(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Path *arg1 = (Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Path, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Path" "', argument " "1"" of type '" "Path *""'"); 
  }
  arg1 = reinterpret_cast< Path * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Path_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Path, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SamplePath_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Path *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplePath_value" "', argument " "1"" of type '" "Sample< Path > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Path > * >(argp1);
  {
    try {
      result = (Path *) &Sample_Sl_Path_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SamplePath_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplePath_weight" "', argument " "1"" of type '" "Sample< Path > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Path > * >(argp1);
  {
    try {
      result = (Real)Sample_Sl_Path_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SamplePath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< Path > *arg1 = (Sample< Path > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_Path_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplePath" "', argument " "1"" of type '" "Sample< Path > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< Path > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SamplePath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SampleT_Path_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GaussianPathGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  GaussianRandomSequenceGenerator *arg4 = 0 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussianPathGenerator" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussianPathGenerator" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_GaussianRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianPathGenerator" "', argument " "4"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianPathGenerator" "', argument " "4"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  arg4 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianPathGenerator" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator > *)new PathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,arg2,arg3,(GaussianRandomSequenceGenerator const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianPathGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator > *)new PathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianPathGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussianPathGenerator", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussianPathGenerator__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_GaussianPathGenerator__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussianPathGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PathGenerator< GaussianRandomSequenceGenerator >::PathGenerator(ext::shared_ptr< StochasticProcess > const &,Time,Size,GaussianRandomSequenceGenerator const &,bool)\n"
    "    PathGenerator< GaussianRandomSequenceGenerator >::PathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,GaussianRandomSequenceGenerator const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussianPathGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianPathGenerator_next" "', argument " "1"" of type '" "PathGenerator< GaussianRandomSequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((PathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianPathGenerator_antithetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianPathGenerator_antithetic" "', argument " "1"" of type '" "PathGenerator< GaussianRandomSequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      result = (PathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((PathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianPathGenerator_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianPathGenerator_size" "', argument " "1"" of type '" "PathGenerator< GaussianRandomSequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      result = ((PathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianPathGenerator_timeGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeGrid *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianPathGenerator_timeGrid" "', argument " "1"" of type '" "PathGenerator< GaussianRandomSequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      result = (TimeGrid *) &((PathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->timeGrid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianPathGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianRandomSequenceGenerator > *arg1 = (PathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianPathGenerator" "', argument " "1"" of type '" "PathGenerator< GaussianRandomSequenceGenerator > *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianPathGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianPathGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussianSobolPathGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  GaussianLowDiscrepancySequenceGenerator *arg4 = 0 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSobolPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussianSobolPathGenerator" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussianSobolPathGenerator" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_GaussianSobolPathGenerator" "', argument " "4"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolPathGenerator" "', argument " "4"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg4 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GaussianSobolPathGenerator" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new PathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,arg2,arg3,(GaussianLowDiscrepancySequenceGenerator const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSobolPathGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSobolPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSobolPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSobolPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianSobolPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new PathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianLowDiscrepancySequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSobolPathGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussianSobolPathGenerator", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussianSobolPathGenerator__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_GaussianSobolPathGenerator__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussianSobolPathGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PathGenerator< GaussianLowDiscrepancySequenceGenerator >::PathGenerator(ext::shared_ptr< StochasticProcess > const &,Time,Size,GaussianLowDiscrepancySequenceGenerator const &,bool)\n"
    "    PathGenerator< GaussianLowDiscrepancySequenceGenerator >::PathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,GaussianLowDiscrepancySequenceGenerator const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussianSobolPathGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianSobolPathGenerator_next" "', argument " "1"" of type '" "PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianSobolPathGenerator_antithetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianSobolPathGenerator_antithetic" "', argument " "1"" of type '" "PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      result = (PathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianSobolPathGenerator_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianSobolPathGenerator_size" "', argument " "1"" of type '" "PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      result = ((PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianSobolPathGenerator_timeGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeGrid *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianSobolPathGenerator_timeGrid" "', argument " "1"" of type '" "PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      result = (TimeGrid *) &((PathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->timeGrid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianSobolPathGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (PathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianSobolPathGenerator" "', argument " "1"" of type '" "PathGenerator< GaussianLowDiscrepancySequenceGenerator > *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianSobolPathGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianSobolPathGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterPathGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  Time arg2 ;
  Size arg3 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg4 = 0 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  double val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "4"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "4"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &""'"); 
  }
  arg4 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)new PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >((ext::shared_ptr< StochasticProcess > const &)*arg1,arg2,arg3,(InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterPathGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "3"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "3"" of type '" "InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &""'"); 
  }
  arg3 = reinterpret_cast< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_InvCumulativeMersenneTwisterPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *)new PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvCumulativeMersenneTwisterPathGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_InvCumulativeMersenneTwisterPathGenerator", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_InvCumulativeMersenneTwisterPathGenerator__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_InvCumulativeMersenneTwisterPathGenerator__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InvCumulativeMersenneTwisterPathGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::PathGenerator(ext::shared_ptr< StochasticProcess > const &,Time,Size,InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &,bool)\n"
    "    PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::PathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterPathGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterPathGenerator_next" "', argument " "1"" of type '" "PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > * >(argp1);
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *) &((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterPathGenerator_antithetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterPathGenerator_antithetic" "', argument " "1"" of type '" "PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > * >(argp1);
  {
    try {
      result = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > >::sample_type *) &((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_Path_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterPathGenerator_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterPathGenerator_size" "', argument " "1"" of type '" "PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > * >(argp1);
  {
    try {
      result = ((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvCumulativeMersenneTwisterPathGenerator_timeGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  TimeGrid *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvCumulativeMersenneTwisterPathGenerator_timeGrid" "', argument " "1"" of type '" "PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > * >(argp1);
  {
    try {
      result = (TimeGrid *) &((PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > const *)arg1)->timeGrid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeGrid, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvCumulativeMersenneTwisterPathGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *arg1 = (PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvCumulativeMersenneTwisterPathGenerator" "', argument " "1"" of type '" "PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > *""'"); 
  }
  arg1 = reinterpret_cast< PathGenerator< InverseCumulativeRsg< RandomSequenceGenerator< MersenneTwisterUniformRng >,InverseCumulativeNormal > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvCumulativeMersenneTwisterPathGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_PathGeneratorT_InverseCumulativeRsgT_RandomSequenceGeneratorT_MersenneTwisterUniformRng_t_InverseCumulativeNormal_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *InvCumulativeMersenneTwisterPathGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_MultiPath___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPath *arg1 = (MultiPath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiPath___len__" "', argument " "1"" of type '" "MultiPath const *""'"); 
  }
  arg1 = reinterpret_cast< MultiPath * >(argp1);
  {
    try {
      result = ((MultiPath const *)arg1)->pathSize();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiPath_assetNumber(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPath *arg1 = (MultiPath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiPath_assetNumber" "', argument " "1"" of type '" "MultiPath const *""'"); 
  }
  arg1 = reinterpret_cast< MultiPath * >(argp1);
  {
    try {
      result = ((MultiPath const *)arg1)->assetNumber();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiPath_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPath *arg1 = (MultiPath *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Path *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiPath_at", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiPath_at" "', argument " "1"" of type '" "MultiPath *""'"); 
  }
  arg1 = reinterpret_cast< MultiPath * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiPath_at" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Path *) &(arg1)->at(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiPath___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPath *arg1 = (MultiPath *) 0 ;
  Integer arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Path *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "MultiPath___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiPath___getitem__" "', argument " "1"" of type '" "MultiPath *""'"); 
  }
  arg1 = reinterpret_cast< MultiPath * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultiPath___getitem__" "', argument " "2"" of type '" "Integer""'");
  } 
  arg2 = static_cast< Integer >(val2);
  {
    try {
      result = (Path *) &MultiPath___getitem__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Path, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MultiPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPath *arg1 = (MultiPath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPath, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiPath" "', argument " "1"" of type '" "MultiPath *""'"); 
  }
  arg1 = reinterpret_cast< MultiPath * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultiPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MultiPath, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SampleMultiPath_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MultiPath *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_MultiPath_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleMultiPath_value" "', argument " "1"" of type '" "Sample< MultiPath > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< MultiPath > * >(argp1);
  {
    try {
      result = (MultiPath *) &Sample_Sl_MultiPath_Sg__value(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPath, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampleMultiPath_weight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_MultiPath_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampleMultiPath_weight" "', argument " "1"" of type '" "Sample< MultiPath > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< MultiPath > * >(argp1);
  {
    try {
      result = (Real)Sample_Sl_MultiPath_Sg__weight(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SampleMultiPath(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Sample< MultiPath > *arg1 = (Sample< MultiPath > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampleT_MultiPath_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SampleMultiPath" "', argument " "1"" of type '" "Sample< MultiPath > *""'"); 
  }
  arg1 = reinterpret_cast< Sample< MultiPath > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SampleMultiPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SampleT_MultiPath_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GaussianMultiPathGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianMultiPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new MultiPathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianMultiPathGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp3);
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new MultiPathGenerator< GaussianRandomSequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianMultiPathGenerator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianMultiPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianRandomSequenceGenerator_Sg___SWIG_2((ext::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianMultiPathGenerator__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  GaussianRandomSequenceGenerator *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianRandomSequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMultiPathGenerator" "', argument " "3"" of type '" "GaussianRandomSequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianRandomSequenceGenerator * >(argp3);
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianRandomSequenceGenerator_Sg___SWIG_2((ext::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(GaussianRandomSequenceGenerator const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianMultiPathGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussianMultiPathGenerator", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_GaussianMultiPathGenerator__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_GaussianMultiPathGenerator__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussianMultiPathGenerator__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianRandomSequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussianMultiPathGenerator__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussianMultiPathGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MultiPathGenerator< GaussianRandomSequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,GaussianRandomSequenceGenerator const &,bool)\n"
    "    MultiPathGenerator< GaussianRandomSequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,GaussianRandomSequenceGenerator const &)\n"
    "    MultiPathGenerator< GaussianRandomSequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,std::vector< Time,std::allocator< Time > > const &,GaussianRandomSequenceGenerator const &,bool)\n"
    "    MultiPathGenerator< GaussianRandomSequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,std::vector< Time,std::allocator< Time > > const &,GaussianRandomSequenceGenerator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussianMultiPathGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMultiPathGenerator_next" "', argument " "1"" of type '" "MultiPathGenerator< GaussianRandomSequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< MultiPathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_MultiPath_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianMultiPathGenerator_antithetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMultiPathGenerator_antithetic" "', argument " "1"" of type '" "MultiPathGenerator< GaussianRandomSequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< MultiPathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      result = (MultiPathGenerator< GaussianRandomSequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianRandomSequenceGenerator > const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_MultiPath_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianMultiPathGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPathGenerator< GaussianRandomSequenceGenerator > *arg1 = (MultiPathGenerator< GaussianRandomSequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianMultiPathGenerator" "', argument " "1"" of type '" "MultiPathGenerator< GaussianRandomSequenceGenerator > *""'"); 
  }
  arg1 = reinterpret_cast< MultiPathGenerator< GaussianRandomSequenceGenerator > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianMultiPathGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MultiPathGeneratorT_GaussianRandomSequenceGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianMultiPathGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GaussianSobolMultiPathGenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianLowDiscrepancySequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSobolMultiPathGenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  TimeGrid *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "TimeGrid const &""'"); 
  }
  arg2 = reinterpret_cast< TimeGrid * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp3);
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >((ext::shared_ptr< StochasticProcess > const &)*arg1,(TimeGrid const &)*arg2,(GaussianLowDiscrepancySequenceGenerator const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSobolMultiPathGenerator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianLowDiscrepancySequenceGenerator_Sg___SWIG_2((ext::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(GaussianLowDiscrepancySequenceGenerator const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSobolMultiPathGenerator__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StochasticProcess > *arg1 = 0 ;
  std::vector< Time,std::allocator< Time > > *arg2 = 0 ;
  GaussianLowDiscrepancySequenceGenerator *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StochasticProcess > tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "1"" of type '" "ext::shared_ptr< StochasticProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StochasticProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "2"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianSobolMultiPathGenerator" "', argument " "3"" of type '" "GaussianLowDiscrepancySequenceGenerator const &""'"); 
  }
  arg3 = reinterpret_cast< GaussianLowDiscrepancySequenceGenerator * >(argp3);
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *)new_MultiPathGenerator_Sl_GaussianLowDiscrepancySequenceGenerator_Sg___SWIG_2((ext::shared_ptr< StochasticProcess > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(GaussianLowDiscrepancySequenceGenerator const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GaussianSobolMultiPathGenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_GaussianSobolMultiPathGenerator", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_GaussianSobolMultiPathGenerator__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_GaussianSobolMultiPathGenerator__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussianSobolMultiPathGenerator__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_StochasticProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_GaussianLowDiscrepancySequenceGenerator, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_GaussianSobolMultiPathGenerator__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GaussianSobolMultiPathGenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,GaussianLowDiscrepancySequenceGenerator const &,bool)\n"
    "    MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,TimeGrid const &,GaussianLowDiscrepancySequenceGenerator const &)\n"
    "    MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,std::vector< Time,std::allocator< Time > > const &,GaussianLowDiscrepancySequenceGenerator const &,bool)\n"
    "    MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::MultiPathGenerator(ext::shared_ptr< StochasticProcess > const &,std::vector< Time,std::allocator< Time > > const &,GaussianLowDiscrepancySequenceGenerator const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GaussianSobolMultiPathGenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianSobolMultiPathGenerator_next" "', argument " "1"" of type '" "MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->next();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_MultiPath_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GaussianSobolMultiPathGenerator_antithetic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianSobolMultiPathGenerator_antithetic" "', argument " "1"" of type '" "MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > const *""'"); 
  }
  arg1 = reinterpret_cast< MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      result = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator >::sample_type *) &((MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > const *)arg1)->antithetic();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampleT_MultiPath_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GaussianSobolMultiPathGenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *arg1 = (MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianSobolMultiPathGenerator" "', argument " "1"" of type '" "MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > *""'"); 
  }
  arg1 = reinterpret_cast< MultiPathGenerator< GaussianLowDiscrepancySequenceGenerator > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GaussianSobolMultiPathGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_MultiPathGeneratorT_GaussianLowDiscrepancySequenceGenerator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GaussianSobolMultiPathGenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BrownianBridge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  BrownianBridge *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BrownianBridge" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (BrownianBridge *)new BrownianBridge(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BrownianBridge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrownianBridge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Time,std::allocator< Time > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  BrownianBridge *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrownianBridge" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrownianBridge" "', argument " "1"" of type '" "std::vector< Time,std::allocator< Time > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (BrownianBridge *)new BrownianBridge((std::vector< Time,std::allocator< Time > > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BrownianBridge, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrownianBridge__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  TimeGrid *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  BrownianBridge *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_TimeGrid,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrownianBridge" "', argument " "1"" of type '" "TimeGrid const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrownianBridge" "', argument " "1"" of type '" "TimeGrid const &""'"); 
  }
  arg1 = reinterpret_cast< TimeGrid * >(argp1);
  {
    try {
      result = (BrownianBridge *)new BrownianBridge((TimeGrid const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BrownianBridge, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrownianBridge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BrownianBridge", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_TimeGrid, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BrownianBridge__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BrownianBridge__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BrownianBridge__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BrownianBridge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BrownianBridge::BrownianBridge(Size)\n"
    "    BrownianBridge::BrownianBridge(std::vector< Time,std::allocator< Time > > const &)\n"
    "    BrownianBridge::BrownianBridge(TimeGrid const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_size" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = ((BrownianBridge const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_times" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = ((BrownianBridge const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_leftWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_leftWeight" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = ((BrownianBridge const *)arg1)->leftWeight();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_rightWeight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_rightWeight" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = ((BrownianBridge const *)arg1)->rightWeight();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_stdDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_stdDeviation" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = ((BrownianBridge const *)arg1)->stdDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "BrownianBridge_transform", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_transform" "', argument " "1"" of type '" "BrownianBridge *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BrownianBridge_transform" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BrownianBridge_transform" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = BrownianBridge_transform(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_bridgeIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_bridgeIndex" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = BrownianBridge_bridgeIndex((BrownianBridge const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_leftIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_leftIndex" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = BrownianBridge_leftIndex((BrownianBridge const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BrownianBridge_rightIndex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BrownianBridge_rightIndex" "', argument " "1"" of type '" "BrownianBridge const *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      result = BrownianBridge_rightIndex((BrownianBridge const *)arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BrownianBridge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BrownianBridge *arg1 = (BrownianBridge *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_BrownianBridge, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BrownianBridge" "', argument " "1"" of type '" "BrownianBridge *""'"); 
  }
  arg1 = reinterpret_cast< BrownianBridge * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BrownianBridge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_BrownianBridge, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BrownianBridge_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RungeKutta__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  Real arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RungeKutta" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RungeKutta" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RungeKutta" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >(arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RungeKutta__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RungeKutta" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RungeKutta" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RungeKutta__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RungeKutta" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RungeKutta__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  AdaptiveRungeKutta< Real > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (AdaptiveRungeKutta< Real > *)new AdaptiveRungeKutta< Real >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RungeKutta(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RungeKutta", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RungeKutta__SWIG_3(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RungeKutta__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RungeKutta__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RungeKutta__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RungeKutta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AdaptiveRungeKutta< Real >::AdaptiveRungeKutta(Real const,Real const,Real const)\n"
    "    AdaptiveRungeKutta< Real >::AdaptiveRungeKutta(Real const,Real const)\n"
    "    AdaptiveRungeKutta< Real >::AdaptiveRungeKutta(Real const)\n"
    "    AdaptiveRungeKutta< Real >::AdaptiveRungeKutta()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RungeKutta___call____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AdaptiveRungeKutta< Real > *arg1 = (AdaptiveRungeKutta< Real > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  double arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RungeKutta___call__" "', argument " "1"" of type '" "AdaptiveRungeKutta< Real > *""'"); 
  }
  arg1 = reinterpret_cast< AdaptiveRungeKutta< Real > * >(argp1);
  arg2 = swig_obj[1];
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RungeKutta___call__" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RungeKutta___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RungeKutta___call__" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (double)AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RungeKutta___call____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  AdaptiveRungeKutta< Real > *arg1 = (AdaptiveRungeKutta< Real > *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RungeKutta___call__" "', argument " "1"" of type '" "AdaptiveRungeKutta< Real > *""'"); 
  }
  arg1 = reinterpret_cast< AdaptiveRungeKutta< Real > * >(argp1);
  arg2 = swig_obj[1];
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RungeKutta___call__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RungeKutta___call__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RungeKutta___call__" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RungeKutta___call__" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = AdaptiveRungeKutta_Sl_Real_Sg__operator_Sp__SP___SWIG_1(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_RungeKutta___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "RungeKutta___call__", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RungeKutta___call____SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RungeKutta___call____SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RungeKutta___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    AdaptiveRungeKutta< Real >::operator ()(PyObject *,double,Real,Real)\n"
    "    AdaptiveRungeKutta< Real >::operator ()(PyObject *,std::vector< double,std::allocator< double > > const &,Real,Real)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RungeKutta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  AdaptiveRungeKutta< Real > *arg1 = (AdaptiveRungeKutta< Real > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RungeKutta" "', argument " "1"" of type '" "AdaptiveRungeKutta< Real > *""'"); 
  }
  arg1 = reinterpret_cast< AdaptiveRungeKutta< Real > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RungeKutta_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_AdaptiveRungeKuttaT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RungeKutta_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_DefaultBoundaryCondition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DefaultBoundaryCondition *arg1 = (DefaultBoundaryCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DefaultBoundaryCondition > tempshared1 ;
  ext::shared_ptr< DefaultBoundaryCondition > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DefaultBoundaryCondition_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultBoundaryCondition" "', argument " "1"" of type '" "DefaultBoundaryCondition *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DefaultBoundaryCondition > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DefaultBoundaryCondition > * >(argp1);
      arg1 = const_cast< DefaultBoundaryCondition * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DefaultBoundaryCondition > * >(argp1);
      arg1 = const_cast< DefaultBoundaryCondition * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultBoundaryCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DefaultBoundaryCondition_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NeumannBC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  DefaultBoundaryCondition::Side arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  NeumannBC *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_NeumannBC", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NeumannBC" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NeumannBC" "', argument " "2"" of type '" "DefaultBoundaryCondition::Side""'");
  } 
  arg2 = static_cast< DefaultBoundaryCondition::Side >(val2);
  {
    try {
      result = (NeumannBC *)new NeumannBC(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NeumannBC > *smartresult = result ? new ext::shared_ptr<  NeumannBC >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NeumannBC_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NeumannBC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NeumannBC *arg1 = (NeumannBC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NeumannBC > tempshared1 ;
  ext::shared_ptr< NeumannBC > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NeumannBC_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NeumannBC" "', argument " "1"" of type '" "NeumannBC *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NeumannBC > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NeumannBC > * >(argp1);
      arg1 = const_cast< NeumannBC * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NeumannBC > * >(argp1);
      arg1 = const_cast< NeumannBC * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NeumannBC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NeumannBC_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NeumannBC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DirichletBC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  DefaultBoundaryCondition::Side arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DirichletBC *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DirichletBC", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DirichletBC" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DirichletBC" "', argument " "2"" of type '" "DefaultBoundaryCondition::Side""'");
  } 
  arg2 = static_cast< DefaultBoundaryCondition::Side >(val2);
  {
    try {
      result = (DirichletBC *)new DirichletBC(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  DirichletBC > *smartresult = result ? new ext::shared_ptr<  DirichletBC >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_DirichletBC_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DirichletBC(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DirichletBC *arg1 = (DirichletBC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< DirichletBC > tempshared1 ;
  ext::shared_ptr< DirichletBC > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_DirichletBC_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirichletBC" "', argument " "1"" of type '" "DirichletBC *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  DirichletBC > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  DirichletBC > * >(argp1);
      arg1 = const_cast< DirichletBC * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  DirichletBC > * >(argp1);
      arg1 = const_cast< DirichletBC * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DirichletBC_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_DirichletBC_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DirichletBC_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_TridiagonalOperator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array *arg2 = 0 ;
  Array *arg3 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Array temp3 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  TridiagonalOperator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_TridiagonalOperator", 3, 3, swig_obj)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TridiagonalOperator" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TridiagonalOperator" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TridiagonalOperator" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TridiagonalOperator" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    if (ArrayFromSequence(swig_obj[2],&temp3)) {
      arg3 = &temp3;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res3)) {
        SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TridiagonalOperator" "', argument " "3"" of type '" "Array const &""'");
      }
      if (!argp3) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TridiagonalOperator" "', argument " "3"" of type '" "Array const &""'"); 
      }
      arg3 = reinterpret_cast< Array * >(argp3);
    }
  }
  {
    try {
      result = (TridiagonalOperator *)new TridiagonalOperator((Array const &)*arg1,(Array const &)*arg2,(Array const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_solveFor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator_solveFor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_solveFor" "', argument " "1"" of type '" "TridiagonalOperator const *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TridiagonalOperator_solveFor" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TridiagonalOperator_solveFor" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((TridiagonalOperator const *)arg1)->solveFor((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_applyTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Array result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator_applyTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_applyTo" "', argument " "1"" of type '" "TridiagonalOperator const *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TridiagonalOperator_applyTo" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TridiagonalOperator_applyTo" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      result = ((TridiagonalOperator const *)arg1)->applyTo((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Array(result)), SWIGTYPE_p_Array, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_size" "', argument " "1"" of type '" "TridiagonalOperator const *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  {
    try {
      result = ((TridiagonalOperator const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_setFirstRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator_setFirstRow", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_setFirstRow" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator_setFirstRow" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TridiagonalOperator_setFirstRow" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->setFirstRow(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_setMidRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Size arg2 ;
  Real arg3 ;
  Real arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator_setMidRow", 5, 5, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_setMidRow" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator_setMidRow" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TridiagonalOperator_setMidRow" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TridiagonalOperator_setMidRow" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TridiagonalOperator_setMidRow" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      (arg1)->setMidRow(arg2,arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_setMidRows(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  Real arg3 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator_setMidRows", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_setMidRows" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator_setMidRows" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TridiagonalOperator_setMidRows" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TridiagonalOperator_setMidRows" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      (arg1)->setMidRows(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_setLastRow(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator_setLastRow", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator_setLastRow" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator_setLastRow" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TridiagonalOperator_setLastRow" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->setLastRow(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator_identity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TridiagonalOperator_identity" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = TridiagonalOperator::identity(SWIG_STD_MOVE(arg1));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  TridiagonalOperator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___add__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___add__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TridiagonalOperator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TridiagonalOperator___add__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TridiagonalOperator___add__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  arg2 = reinterpret_cast< TridiagonalOperator * >(argp2);
  {
    try {
      result = TridiagonalOperator___add__(arg1,(TridiagonalOperator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  TridiagonalOperator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___sub__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TridiagonalOperator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TridiagonalOperator___sub__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TridiagonalOperator___sub__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  arg2 = reinterpret_cast< TridiagonalOperator * >(argp2);
  {
    try {
      result = TridiagonalOperator___sub__(arg1,(TridiagonalOperator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___mul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___mul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___mul__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator___mul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = TridiagonalOperator___mul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___div__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___div__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___div__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator___div__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = TridiagonalOperator___div__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  TridiagonalOperator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___iadd__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TridiagonalOperator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TridiagonalOperator___iadd__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TridiagonalOperator___iadd__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  arg2 = reinterpret_cast< TridiagonalOperator * >(argp2);
  {
    try {
      result = TridiagonalOperator___iadd__(arg1,(TridiagonalOperator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  TridiagonalOperator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___isub__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TridiagonalOperator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TridiagonalOperator___isub__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TridiagonalOperator___isub__" "', argument " "2"" of type '" "TridiagonalOperator const &""'"); 
  }
  arg2 = reinterpret_cast< TridiagonalOperator * >(argp2);
  {
    try {
      result = TridiagonalOperator___isub__(arg1,(TridiagonalOperator const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___imul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___imul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___imul__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator___imul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = TridiagonalOperator___imul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___rmul__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___rmul__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___rmul__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator___rmul__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = TridiagonalOperator___rmul__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_TridiagonalOperator___idiv__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< TridiagonalOperator > result;
  
  if (!SWIG_Python_UnpackTuple(args, "TridiagonalOperator___idiv__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TridiagonalOperator___idiv__" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TridiagonalOperator___idiv__" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = TridiagonalOperator___idiv__(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TridiagonalOperator(result)), SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TridiagonalOperator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  TridiagonalOperator *arg1 = (TridiagonalOperator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_TridiagonalOperator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TridiagonalOperator" "', argument " "1"" of type '" "TridiagonalOperator *""'"); 
  }
  arg1 = reinterpret_cast< TridiagonalOperator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TridiagonalOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_TridiagonalOperator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *TridiagonalOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DPlus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DPlus *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DPlus", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DPlus" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DPlus" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (DPlus *)new DPlus(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DPlus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DPlus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DPlus *arg1 = (DPlus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DPlus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DPlus" "', argument " "1"" of type '" "DPlus *""'"); 
  }
  arg1 = reinterpret_cast< DPlus * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DPlus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DPlus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DPlus_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DMinus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DMinus *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DMinus", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DMinus" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DMinus" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (DMinus *)new DMinus(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DMinus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DMinus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DMinus *arg1 = (DMinus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DMinus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DMinus" "', argument " "1"" of type '" "DMinus *""'"); 
  }
  arg1 = reinterpret_cast< DMinus * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DMinus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DMinus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DMinus_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DZero *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DZero", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DZero" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DZero" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (DZero *)new DZero(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DZero, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DZero(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DZero *arg1 = (DZero *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DZero, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DZero" "', argument " "1"" of type '" "DZero *""'"); 
  }
  arg1 = reinterpret_cast< DZero * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DZero_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DZero, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DZero_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_DPlusDMinus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Real arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  DPlusDMinus *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_DPlusDMinus", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DPlusDMinus" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DPlusDMinus" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (DPlusDMinus *)new DPlusDMinus(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DPlusDMinus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DPlusDMinus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  DPlusDMinus *arg1 = (DPlusDMinus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_DPlusDMinus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DPlusDMinus" "', argument " "1"" of type '" "DPlusDMinus *""'"); 
  }
  arg1 = reinterpret_cast< DPlusDMinus * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DPlusDMinus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_DPlusDMinus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DPlusDMinus_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SampledCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  SampledCurve *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (SampledCurve *)new SampledCurve();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampledCurve, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SampledCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Array *arg1 = 0 ;
  Array temp1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SampledCurve *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    if (ArrayFromSequence(swig_obj[0],&temp1)) {
      arg1 = &temp1;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SampledCurve" "', argument " "1"" of type '" "Array const &""'");
      }
      if (!argp1) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SampledCurve" "', argument " "1"" of type '" "Array const &""'"); 
      }
      arg1 = reinterpret_cast< Array * >(argp1);
    }
  }
  {
    try {
      result = (SampledCurve *)new SampledCurve((Array const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SampledCurve, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SampledCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SampledCurve", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SampledCurve__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      /* native sequence? */
      if (PyTuple_Check(argv[0]) || PyList_Check(argv[0])) {
        Size size = PySequence_Size(argv[0]);
        if (size == 0) {
          _v = 1;
        } else {
          PyObject* o = PySequence_GetItem(argv[0],0);
          if (PyNumber_Check(o))
          _v = 1;
          else
          _v = 0;
          Py_DECREF(o);
        }
      } else {
        // copied from SWIGTYPE typemap -- might need updating for newer SWIG
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (_v) {
      return _wrap_new_SampledCurve__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SampledCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    SampledCurve::SampledCurve()\n"
    "    SampledCurve::SampledCurve(Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SampledCurve_grid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_grid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    try {
      result = (Array *) &(arg1)->grid();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Array *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_values" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    try {
      result = (Array *) &(arg1)->values();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Array, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_gridValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_gridValue", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_gridValue" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SampledCurve_gridValue" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)(arg1)->gridValue(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_value", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_value" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SampledCurve_value" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (Real)(arg1)->value(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_size" "', argument " "1"" of type '" "SampledCurve const *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    try {
      result = ((SampledCurve const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_empty" "', argument " "1"" of type '" "SampledCurve const *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    try {
      result = (bool)((SampledCurve const *)arg1)->empty();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_setGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_setGrid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_setGrid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SampledCurve_setGrid" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SampledCurve_setGrid" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->setGrid((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_setValues(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_setValues", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_setValues" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SampledCurve_setValues" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SampledCurve_setValues" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->setValues((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  SampledCurve *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_swap" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SampledCurve,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SampledCurve_swap" "', argument " "2"" of type '" "SampledCurve &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SampledCurve_swap" "', argument " "2"" of type '" "SampledCurve &""'"); 
  }
  arg2 = reinterpret_cast< SampledCurve * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_setLogGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_setLogGrid", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_setLogGrid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SampledCurve_setLogGrid" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SampledCurve_setLogGrid" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->setLogGrid(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_regridLogGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_regridLogGrid", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_regridLogGrid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SampledCurve_regridLogGrid" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SampledCurve_regridLogGrid" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->regridLogGrid(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_shiftGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_shiftGrid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_shiftGrid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SampledCurve_shiftGrid" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->shiftGrid(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_scaleGrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_scaleGrid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_scaleGrid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SampledCurve_scaleGrid" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->scaleGrid(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SampledCurve_regrid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "SampledCurve_regrid", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SampledCurve_regrid" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SampledCurve_regrid" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SampledCurve_regrid" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->regrid((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SampledCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SampledCurve *arg1 = (SampledCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SampledCurve, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SampledCurve" "', argument " "1"" of type '" "SampledCurve *""'"); 
  }
  arg1 = reinterpret_cast< SampledCurve * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SampledCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SampledCurve, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SampledCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonSLVProcess__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  HestonSLVProcess *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVProcess" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVProcess" "', argument " "2"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HestonSLVProcess" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      result = (HestonSLVProcess *)new HestonSLVProcess((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< LocalVolTermStructure > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonSLVProcess > *smartresult = result ? new ext::shared_ptr<  HestonSLVProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonSLVProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVProcess__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< HestonProcess > *arg1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared2 ;
  HestonSLVProcess *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVProcess" "', argument " "1"" of type '" "ext::shared_ptr< HestonProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< HestonProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVProcess" "', argument " "2"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (HestonSLVProcess *)new HestonSLVProcess((ext::shared_ptr< HestonProcess > const &)*arg1,(ext::shared_ptr< LocalVolTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonSLVProcess > *smartresult = result ? new ext::shared_ptr<  HestonSLVProcess >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonSLVProcess_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonSLVProcess", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_HestonSLVProcess__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_HestonSLVProcess__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonSLVProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonSLVProcess::HestonSLVProcess(ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< LocalVolTermStructure > const &,Real const)\n"
    "    HestonSLVProcess::HestonSLVProcess(ext::shared_ptr< HestonProcess > const &,ext::shared_ptr< LocalVolTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HestonSLVProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVProcess *arg1 = (HestonSLVProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< HestonSLVProcess > tempshared1 ;
  ext::shared_ptr< HestonSLVProcess > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_HestonSLVProcess_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonSLVProcess" "', argument " "1"" of type '" "HestonSLVProcess *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  HestonSLVProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  HestonSLVProcess > * >(argp1);
      arg1 = const_cast< HestonSLVProcess * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  HestonSLVProcess > * >(argp1);
      arg1 = const_cast< HestonSLVProcess * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonSLVProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_HestonSLVProcess_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonSLVProcess_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  std::vector< Date,std::allocator< Date > > *arg8 = 0 ;
  Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  double val9 ;
  int ecode9 = 0 ;
  HestonSLVMCModel *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVMCModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVMCModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVMCModel" "', argument " "3"" of type '" "ext::shared_ptr< BrownianGeneratorFactory > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVMCModel" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonSLVMCModel" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonSLVMCModel" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_HestonSLVMCModel" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg8 = ptr;
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HestonSLVMCModel" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),(std::vector< Date,std::allocator< Date > > const &)*arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  std::vector< Date,std::allocator< Date > > *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  HestonSLVMCModel *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVMCModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVMCModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVMCModel" "', argument " "3"" of type '" "ext::shared_ptr< BrownianGeneratorFactory > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVMCModel" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonSLVMCModel" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonSLVMCModel" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res8 = swig::asptr(swig_obj[7], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_HestonSLVMCModel" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "8"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg8 = ptr;
  }
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),(std::vector< Date,std::allocator< Date > > const &)*arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res8)) delete arg8;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res8)) delete arg8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  Size arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  HestonSLVMCModel *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVMCModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVMCModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVMCModel" "', argument " "3"" of type '" "ext::shared_ptr< BrownianGeneratorFactory > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVMCModel" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonSLVMCModel" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonSLVMCModel" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  Size arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  HestonSLVMCModel *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVMCModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVMCModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVMCModel" "', argument " "3"" of type '" "ext::shared_ptr< BrownianGeneratorFactory > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVMCModel" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonSLVMCModel" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  HestonSLVMCModel *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVMCModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVMCModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVMCModel" "', argument " "3"" of type '" "ext::shared_ptr< BrownianGeneratorFactory > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVMCModel" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4,SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > *arg3 = 0 ;
  Date *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  ext::shared_ptr< BrownianGeneratorFactory > tempshared3 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  HestonSLVMCModel *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVMCModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVMCModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVMCModel" "', argument " "3"" of type '" "ext::shared_ptr< BrownianGeneratorFactory > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      delete reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< ext::shared_ptr< BrownianGeneratorFactory > * >(argp3) : &tempshared3;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVMCModel" "', argument " "4"" of type '" "Date const &""'"); 
  }
  arg4 = reinterpret_cast< Date * >(argp4);
  {
    try {
      result = (HestonSLVMCModel *)new_HestonSLVMCModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(ext::shared_ptr< BrownianGeneratorFactory > const &)*arg3,(Date const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVMCModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonSLVMCModel", 0, 9, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_HestonSLVMCModel__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_HestonSLVMCModel__SWIG_4(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_HestonSLVMCModel__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_HestonSLVMCModel__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< Date,std::allocator< Date > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_new_HestonSLVMCModel__SWIG_1(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ext__shared_ptrT_BrownianGeneratorFactory_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< Date,std::allocator< Date > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_HestonSLVMCModel__SWIG_0(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonSLVMCModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonSLVMCModel::HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,ext::shared_ptr< BrownianGeneratorFactory > const &,Date const &,Size,Size,Size,std::vector< Date,std::allocator< Date > > const &,Real)\n"
    "    HestonSLVMCModel::HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,ext::shared_ptr< BrownianGeneratorFactory > const &,Date const &,Size,Size,Size,std::vector< Date,std::allocator< Date > > const &)\n"
    "    HestonSLVMCModel::HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,ext::shared_ptr< BrownianGeneratorFactory > const &,Date const &,Size,Size,Size)\n"
    "    HestonSLVMCModel::HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,ext::shared_ptr< BrownianGeneratorFactory > const &,Date const &,Size,Size)\n"
    "    HestonSLVMCModel::HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,ext::shared_ptr< BrownianGeneratorFactory > const &,Date const &,Size)\n"
    "    HestonSLVMCModel::HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,ext::shared_ptr< BrownianGeneratorFactory > const &,Date const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HestonSLVMCModel_hestonProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< HestonProcess > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVMCModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonSLVMCModel_hestonProcess" "', argument " "1"" of type '" "HestonSLVMCModel const *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVMCModel * >(argp1);
  {
    try {
      result = ((HestonSLVMCModel const *)arg1)->hestonProcess();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonProcess > *smartresult = result ? new ext::shared_ptr<  HestonProcess >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonSLVMCModel_localVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVMCModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonSLVMCModel_localVol" "', argument " "1"" of type '" "HestonSLVMCModel const *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVMCModel * >(argp1);
  {
    try {
      result = ((HestonSLVMCModel const *)arg1)->localVol();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolTermStructure > *smartresult = result ? new ext::shared_ptr<  LocalVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonSLVMCModel_leverageFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVMCModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonSLVMCModel_leverageFunction" "', argument " "1"" of type '" "HestonSLVMCModel const *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVMCModel * >(argp1);
  {
    try {
      result = ((HestonSLVMCModel const *)arg1)->leverageFunction();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolTermStructure > *smartresult = result ? new ext::shared_ptr<  LocalVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonSLVMCModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVMCModel *arg1 = (HestonSLVMCModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVMCModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonSLVMCModel" "', argument " "1"" of type '" "HestonSLVMCModel *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVMCModel * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonSLVMCModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HestonSLVMCModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonSLVMCModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_FdmHestonGreensFct(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdmHestonGreensFct *arg1 = (FdmHestonGreensFct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FdmHestonGreensFct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdmHestonGreensFct" "', argument " "1"" of type '" "FdmHestonGreensFct *""'"); 
  }
  arg1 = reinterpret_cast< FdmHestonGreensFct * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdmHestonGreensFct_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FdmHestonGreensFct, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HestonSLVFokkerPlanckFdmParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  Size arg2 ;
  Size arg3 ;
  Size arg4 ;
  Real arg5 ;
  Size arg6 ;
  Size arg7 ;
  Real arg8 ;
  Real arg9 ;
  Size arg10 ;
  Real arg11 ;
  Real arg12 ;
  Real arg13 ;
  Real arg14 ;
  Real arg15 ;
  Real arg16 ;
  Real arg17 ;
  FdmHestonGreensFct::Algorithm arg18 ;
  FdmSquareRootFwdOp::TransformationType arg19 ;
  SwigValueWrapper< FdmSchemeDesc > arg20 ;
  size_t 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 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  void *argp20 ;
  int res20 = 0 ;
  PyObject *swig_obj[20] ;
  HestonSLVFokkerPlanckFdmParams *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_HestonSLVFokkerPlanckFdmParams", 20, 20, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "6"" of type '" "Size""'");
  } 
  arg6 = static_cast< Size >(val6);
  ecode7 = SWIG_AsVal_size_t(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "7"" of type '" "Size""'");
  } 
  arg7 = static_cast< Size >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "8"" of type '" "Real""'");
  } 
  arg8 = static_cast< Real >(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "9"" of type '" "Real""'");
  } 
  arg9 = static_cast< Real >(val9);
  ecode10 = SWIG_AsVal_size_t(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "10"" of type '" "Size""'");
  } 
  arg10 = static_cast< Size >(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "11"" of type '" "Real""'");
  } 
  arg11 = static_cast< Real >(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "12"" of type '" "Real""'");
  } 
  arg12 = static_cast< Real >(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "13"" of type '" "Real""'");
  } 
  arg13 = static_cast< Real >(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "14"" of type '" "Real""'");
  } 
  arg14 = static_cast< Real >(val14);
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "15"" of type '" "Real""'");
  } 
  arg15 = static_cast< Real >(val15);
  ecode16 = SWIG_AsVal_double(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "16"" of type '" "Real""'");
  } 
  arg16 = static_cast< Real >(val16);
  ecode17 = SWIG_AsVal_double(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "17"" of type '" "Real""'");
  } 
  arg17 = static_cast< Real >(val17);
  ecode18 = SWIG_AsVal_int(swig_obj[17], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "18"" of type '" "FdmHestonGreensFct::Algorithm""'");
  } 
  arg18 = static_cast< FdmHestonGreensFct::Algorithm >(val18);
  ecode19 = SWIG_AsVal_int(swig_obj[18], &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "19"" of type '" "FdmSquareRootFwdOp::TransformationType""'");
  } 
  arg19 = static_cast< FdmSquareRootFwdOp::TransformationType >(val19);
  {
    res20 = SWIG_ConvertPtr(swig_obj[19], &argp20, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
    if (!SWIG_IsOK(res20)) {
      SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "20"" of type '" "FdmSchemeDesc""'"); 
    }  
    if (!argp20) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFokkerPlanckFdmParams" "', argument " "20"" of type '" "FdmSchemeDesc""'");
    } else {
      FdmSchemeDesc * temp = reinterpret_cast< FdmSchemeDesc * >(argp20);
      arg20 = *temp;
      if (SWIG_IsNewObj(res20)) delete temp;
    }
  }
  {
    try {
      result = (HestonSLVFokkerPlanckFdmParams *)new_HestonSLVFokkerPlanckFdmParams(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7),arg8,arg9,SWIG_STD_MOVE(arg10),arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,SWIG_STD_MOVE(arg20));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonSLVFokkerPlanckFdmParams(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVFokkerPlanckFdmParams *arg1 = (HestonSLVFokkerPlanckFdmParams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonSLVFokkerPlanckFdmParams" "', argument " "1"" of type '" "HestonSLVFokkerPlanckFdmParams *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVFokkerPlanckFdmParams * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonSLVFokkerPlanckFdmParams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonSLVFokkerPlanckFdmParams_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_HestonSLVFDMModel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  bool arg5 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  Real arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  double val7 ;
  int ecode7 = 0 ;
  HestonSLVFDMModel *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVFDMModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVFDMModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  arg4 = reinterpret_cast< HestonSLVFokkerPlanckFdmParams * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVFDMModel" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_HestonSLVFDMModel" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HestonSLVFDMModel" "', argument " "7"" of type '" "Real""'");
  } 
  arg7 = static_cast< Real >(val7);
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams const &)*arg4,arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVFDMModel, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVFDMModel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  bool arg5 ;
  std::vector< Date,std::allocator< Date > > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  HestonSLVFDMModel *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVFDMModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVFDMModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  arg4 = reinterpret_cast< HestonSLVFokkerPlanckFdmParams * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVFDMModel" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_HestonSLVFDMModel" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "6"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams const &)*arg4,arg5,(std::vector< Date,std::allocator< Date > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVFDMModel, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVFDMModel__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  HestonSLVFDMModel *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVFDMModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVFDMModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  arg4 = reinterpret_cast< HestonSLVFokkerPlanckFdmParams * >(argp4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HestonSLVFDMModel" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams const &)*arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVFDMModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVFDMModel__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< LocalVolTermStructure > *arg1 = 0 ;
  ext::shared_ptr< HestonModel > *arg2 = 0 ;
  Date *arg3 = 0 ;
  HestonSLVFokkerPlanckFdmParams *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< LocalVolTermStructure > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< HestonModel > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  HestonSLVFDMModel *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HestonSLVFDMModel" "', argument " "1"" of type '" "ext::shared_ptr< LocalVolTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< LocalVolTermStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HestonSLVFDMModel" "', argument " "2"" of type '" "ext::shared_ptr< HestonModel > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< HestonModel > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "3"" of type '" "Date const &""'"); 
  }
  arg3 = reinterpret_cast< Date * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HestonSLVFDMModel" "', argument " "4"" of type '" "HestonSLVFokkerPlanckFdmParams const &""'"); 
  }
  arg4 = reinterpret_cast< HestonSLVFokkerPlanckFdmParams * >(argp4);
  {
    try {
      result = (HestonSLVFDMModel *)new_HestonSLVFDMModel__SWIG_0((ext::shared_ptr< LocalVolTermStructure > const &)*arg1,(ext::shared_ptr< HestonModel > const &)*arg2,(Date const &)*arg3,(HestonSLVFokkerPlanckFdmParams const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HestonSLVFDMModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HestonSLVFDMModel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HestonSLVFDMModel", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_HestonSLVFDMModel__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_HestonSLVFDMModel__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_HestonSLVFDMModel__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_HestonModel_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_HestonSLVFokkerPlanckFdmParams, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< Date,std::allocator< Date > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_HestonSLVFDMModel__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HestonSLVFDMModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    HestonSLVFDMModel::HestonSLVFDMModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,Date const &,HestonSLVFokkerPlanckFdmParams const &,bool const,std::vector< Date,std::allocator< Date > > const &,Real)\n"
    "    HestonSLVFDMModel::HestonSLVFDMModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,Date const &,HestonSLVFokkerPlanckFdmParams const &,bool const,std::vector< Date,std::allocator< Date > > const &)\n"
    "    HestonSLVFDMModel::HestonSLVFDMModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,Date const &,HestonSLVFokkerPlanckFdmParams const &,bool const)\n"
    "    HestonSLVFDMModel::HestonSLVFDMModel(ext::shared_ptr< LocalVolTermStructure > const &,ext::shared_ptr< HestonModel > const &,Date const &,HestonSLVFokkerPlanckFdmParams const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HestonSLVFDMModel_hestonProcess(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< HestonProcess > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVFDMModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonSLVFDMModel_hestonProcess" "', argument " "1"" of type '" "HestonSLVFDMModel const *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVFDMModel * >(argp1);
  {
    try {
      result = ((HestonSLVFDMModel const *)arg1)->hestonProcess();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  HestonProcess > *smartresult = result ? new ext::shared_ptr<  HestonProcess >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_HestonProcess_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonSLVFDMModel_localVol(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVFDMModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonSLVFDMModel_localVol" "', argument " "1"" of type '" "HestonSLVFDMModel const *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVFDMModel * >(argp1);
  {
    try {
      result = ((HestonSLVFDMModel const *)arg1)->localVol();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolTermStructure > *smartresult = result ? new ext::shared_ptr<  LocalVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HestonSLVFDMModel_leverageFunction(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< LocalVolTermStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVFDMModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HestonSLVFDMModel_leverageFunction" "', argument " "1"" of type '" "HestonSLVFDMModel const *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVFDMModel * >(argp1);
  {
    try {
      result = ((HestonSLVFDMModel const *)arg1)->leverageFunction();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  LocalVolTermStructure > *smartresult = result ? new ext::shared_ptr<  LocalVolTermStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_LocalVolTermStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HestonSLVFDMModel(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  HestonSLVFDMModel *arg1 = (HestonSLVFDMModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HestonSLVFDMModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HestonSLVFDMModel" "', argument " "1"" of type '" "HestonSLVFDMModel *""'"); 
  }
  arg1 = reinterpret_cast< HestonSLVFDMModel * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HestonSLVFDMModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HestonSLVFDMModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HestonSLVFDMModel_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SpreadOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< PlainVanillaPayoff > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< PlainVanillaPayoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  PyObject *swig_obj[2] ;
  SpreadOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_SpreadOption", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_PlainVanillaPayoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadOption" "', argument " "1"" of type '" "ext::shared_ptr< PlainVanillaPayoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< PlainVanillaPayoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpreadOption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (SpreadOption *)new SpreadOption((ext::shared_ptr< PlainVanillaPayoff > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  SpreadOption > *smartresult = result ? new ext::shared_ptr<  SpreadOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_SpreadOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SpreadOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SpreadOption *arg1 = (SpreadOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< SpreadOption > tempshared1 ;
  ext::shared_ptr< SpreadOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_SpreadOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadOption" "', argument " "1"" of type '" "SpreadOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  SpreadOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  SpreadOption > * >(argp1);
      arg1 = const_cast< SpreadOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  SpreadOption > * >(argp1);
      arg1 = const_cast< SpreadOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_SpreadOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SpreadOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KirkSpreadOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< BlackProcess > *arg1 = 0 ;
  ext::shared_ptr< BlackProcess > *arg2 = 0 ;
  Handle< Quote > *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< BlackProcess > tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  KirkSpreadOptionEngine *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_KirkSpreadOptionEngine", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KirkSpreadOptionEngine" "', argument " "1"" of type '" "ext::shared_ptr< BlackProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_BlackProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KirkSpreadOptionEngine" "', argument " "2"" of type '" "ext::shared_ptr< BlackProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< BlackProcess > * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KirkSpreadOptionEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KirkSpreadOptionEngine" "', argument " "3"" of type '" "Handle< Quote > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< Quote > * >(argp3);
  {
    try {
      result = (KirkSpreadOptionEngine *)new KirkSpreadOptionEngine((ext::shared_ptr< BlackProcess > const &)*arg1,(ext::shared_ptr< BlackProcess > const &)*arg2,(Handle< Quote > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  KirkSpreadOptionEngine > *smartresult = result ? new ext::shared_ptr<  KirkSpreadOptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_KirkSpreadOptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KirkSpreadOptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  KirkSpreadOptionEngine *arg1 = (KirkSpreadOptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< KirkSpreadOptionEngine > tempshared1 ;
  ext::shared_ptr< KirkSpreadOptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_KirkSpreadOptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KirkSpreadOptionEngine" "', argument " "1"" of type '" "KirkSpreadOptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  KirkSpreadOptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  KirkSpreadOptionEngine > * >(argp1);
      arg1 = const_cast< KirkSpreadOptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  KirkSpreadOptionEngine > * >(argp1);
      arg1 = const_cast< KirkSpreadOptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KirkSpreadOptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_KirkSpreadOptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KirkSpreadOptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_Statistics_samples(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_samples" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = ((Statistics const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_weightSum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_weightSum" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_mean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_mean" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_variance" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_standardDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_standardDeviation" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_errorEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_errorEstimate" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_skewness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_skewness" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_kurtosis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_kurtosis" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_min" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->min();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_max" "', argument " "1"" of type '" "Statistics const *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      result = (Real)((Statistics const *)arg1)->max();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_reset" "', argument " "1"" of type '" "Statistics *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_add" "', argument " "1"" of type '" "Statistics *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Statistics_add" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Statistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_add" "', argument " "1"" of type '" "Statistics *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Statistics_add" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->add(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_add" "', argument " "1"" of type '" "Statistics *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Statistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Statistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      Statistics_add__SWIG_2(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Statistics_add" "', argument " "1"" of type '" "Statistics *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Statistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Statistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Statistics_add" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Statistics_add" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      Statistics_add__SWIG_3(arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Statistics_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Statistics_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Statistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Statistics_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Statistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Statistics_add__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Statistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Statistics_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Statistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Statistics_add__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Statistics_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Statistics::add(Real,Real)\n"
    "    Statistics::add(Real)\n"
    "    Statistics::add(std::vector< Real,std::allocator< Real > > const &)\n"
    "    Statistics::add(std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_Statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Statistics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Statistics *)new Statistics();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Statistics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Statistics *arg1 = (Statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Statistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Statistics" "', argument " "1"" of type '" "Statistics *""'"); 
  }
  arg1 = reinterpret_cast< Statistics * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Statistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Statistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Statistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_IncrementalStatistics_samples(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_samples" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = ((IncrementalStatistics const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_weightSum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_weightSum" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_mean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_mean" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_variance" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_standardDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_standardDeviation" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_errorEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_errorEstimate" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_skewness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_skewness" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_kurtosis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_kurtosis" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_min" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->min();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_max" "', argument " "1"" of type '" "IncrementalStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      result = (Real)((IncrementalStatistics const *)arg1)->max();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_reset" "', argument " "1"" of type '" "IncrementalStatistics *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real arg2 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_add" "', argument " "1"" of type '" "IncrementalStatistics *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IncrementalStatistics_add" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IncrementalStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_add" "', argument " "1"" of type '" "IncrementalStatistics *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IncrementalStatistics_add" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      (arg1)->add(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_add" "', argument " "1"" of type '" "IncrementalStatistics *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      IncrementalStatistics_add__SWIG_2(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  std::vector< Real,std::allocator< Real > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementalStatistics_add" "', argument " "1"" of type '" "IncrementalStatistics *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncrementalStatistics_add" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncrementalStatistics_add" "', argument " "3"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      IncrementalStatistics_add__SWIG_3(arg1,(std::vector< double,std::allocator< double > > const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncrementalStatistics_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IncrementalStatistics_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IncrementalStatistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IncrementalStatistics_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IncrementalStatistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IncrementalStatistics_add__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IncrementalStatistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IncrementalStatistics_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_IncrementalStatistics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IncrementalStatistics_add__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IncrementalStatistics_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    IncrementalStatistics::add(Real,Real)\n"
    "    IncrementalStatistics::add(Real)\n"
    "    IncrementalStatistics::add(std::vector< Real,std::allocator< Real > > const &)\n"
    "    IncrementalStatistics::add(std::vector< Real,std::allocator< Real > > const &,std::vector< Real,std::allocator< Real > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IncrementalStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_IncrementalStatistics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (IncrementalStatistics *)new IncrementalStatistics();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IncrementalStatistics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IncrementalStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  IncrementalStatistics *arg1 = (IncrementalStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IncrementalStatistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncrementalStatistics" "', argument " "1"" of type '" "IncrementalStatistics *""'"); 
  }
  arg1 = reinterpret_cast< IncrementalStatistics * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IncrementalStatistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_IncrementalStatistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IncrementalStatistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_RiskStatistics_semiVariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_semiVariance" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->semiVariance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_semiDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_semiDeviation" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->semiDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_downsideVariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_downsideVariance" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->downsideVariance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_downsideDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_downsideDeviation" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->downsideDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_regret(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskStatistics_regret", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_regret" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskStatistics_regret" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->regret(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_potentialUpside(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskStatistics_potentialUpside", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_potentialUpside" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskStatistics_potentialUpside" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->potentialUpside(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_valueAtRisk(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskStatistics_valueAtRisk", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_valueAtRisk" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskStatistics_valueAtRisk" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->valueAtRisk(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_expectedShortfall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskStatistics_expectedShortfall", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_expectedShortfall" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskStatistics_expectedShortfall" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->expectedShortfall(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_shortfall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskStatistics_shortfall", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_shortfall" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskStatistics_shortfall" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->shortfall(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RiskStatistics_averageShortfall(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  Real result;
  
  if (!SWIG_Python_UnpackTuple(args, "RiskStatistics_averageShortfall", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RiskStatistics_averageShortfall" "', argument " "1"" of type '" "RiskStatistics const *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RiskStatistics_averageShortfall" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (Real)((RiskStatistics const *)arg1)->averageShortfall(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_RiskStatistics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (RiskStatistics *)new RiskStatistics();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RiskStatistics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RiskStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RiskStatistics *arg1 = (RiskStatistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RiskStatistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RiskStatistics" "', argument " "1"" of type '" "RiskStatistics *""'"); 
  }
  arg1 = reinterpret_cast< RiskStatistics * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RiskStatistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RiskStatistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RiskStatistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MultipleStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GenericSequenceStatistics< Statistics > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MultipleStatistics" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GenericSequenceStatistics< Statistics > *)new GenericSequenceStatistics< Statistics >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_size" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_samples(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_samples" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_weightSum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_weightSum" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = (Real)((GenericSequenceStatistics< Statistics > const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_mean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_mean" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_variance" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_standardDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_standardDeviation" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_errorEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_errorEstimate" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_skewness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_skewness" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_kurtosis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_kurtosis" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_min" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->min();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_max" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->max();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_covariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_covariance" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->covariance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_correlation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_correlation" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< Statistics > const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_reset" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipleStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((std::vector< Real,std::allocator< Real > > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->add((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipleStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleStatistics_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleStatistics_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultipleStatistics_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultipleStatistics_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_MultipleStatistics_add__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MultipleStatistics_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MultipleStatistics_add__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultipleStatistics_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GenericSequenceStatistics< Statistics >::add(std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    GenericSequenceStatistics< Statistics >::add(std::vector< Real,std::allocator< Real > > const &)\n"
    "    GenericSequenceStatistics< Statistics >::add(Array const &,Real)\n"
    "    GenericSequenceStatistics< Statistics >::add(Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultipleStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< Statistics > *arg1 = (GenericSequenceStatistics< Statistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultipleStatistics" "', argument " "1"" of type '" "GenericSequenceStatistics< Statistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< Statistics > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultipleStatistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GenericSequenceStatisticsT_Statistics_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MultipleStatistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_SequenceStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GenericSequenceStatistics< RiskStatistics > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SequenceStatistics" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GenericSequenceStatistics< RiskStatistics > *)new GenericSequenceStatistics< RiskStatistics >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_size" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_samples(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_samples" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_weightSum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_weightSum" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = (Real)((GenericSequenceStatistics< RiskStatistics > const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_mean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_mean" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_variance" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_standardDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_standardDeviation" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_errorEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_errorEstimate" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_skewness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_skewness" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_kurtosis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_kurtosis" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_min" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->min();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_max" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->max();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_covariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_covariance" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->covariance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_correlation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_correlation" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< RiskStatistics > const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_reset" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SequenceStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((std::vector< Real,std::allocator< Real > > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->add((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SequenceStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SequenceStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SequenceStatistics_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SequenceStatistics_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SequenceStatistics_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SequenceStatistics_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_SequenceStatistics_add__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SequenceStatistics_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SequenceStatistics_add__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SequenceStatistics_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GenericSequenceStatistics< RiskStatistics >::add(std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    GenericSequenceStatistics< RiskStatistics >::add(std::vector< Real,std::allocator< Real > > const &)\n"
    "    GenericSequenceStatistics< RiskStatistics >::add(Array const &,Real)\n"
    "    GenericSequenceStatistics< RiskStatistics >::add(Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SequenceStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< RiskStatistics > *arg1 = (GenericSequenceStatistics< RiskStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SequenceStatistics" "', argument " "1"" of type '" "GenericSequenceStatistics< RiskStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< RiskStatistics > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SequenceStatistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GenericSequenceStatisticsT_RiskStatistics_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SequenceStatistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MultipleIncrementalStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GenericSequenceStatistics< IncrementalStatistics > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MultipleIncrementalStatistics" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (GenericSequenceStatistics< IncrementalStatistics > *)new GenericSequenceStatistics< IncrementalStatistics >(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_size" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->size();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_samples(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_samples" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->samples();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_weightSum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_weightSum" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = (Real)((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->weightSum();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_mean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_mean" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->mean();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_variance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_variance" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->variance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_standardDeviation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_standardDeviation" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->standardDeviation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_errorEstimate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_errorEstimate" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->errorEstimate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_skewness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_skewness" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->skewness();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_kurtosis(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_kurtosis" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->kurtosis();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_min" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->min();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_max" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->max();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_covariance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_covariance" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->covariance();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_correlation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_correlation" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > const *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      result = ((GenericSequenceStatistics< IncrementalStatistics > const *)arg1)->correlation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Matrix(result)), SWIGTYPE_p_Matrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_reset" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      (arg1)->reset();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_add__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipleIncrementalStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((std::vector< Real,std::allocator< Real > > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_add__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  std::vector< Real,std::allocator< Real > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "std::vector< Real,std::allocator< Real > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->add((std::vector< Real,std::allocator< Real > > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_add__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Array *arg2 = 0 ;
  Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipleIncrementalStatistics_add" "', argument " "3"" of type '" "Real""'");
  } 
  arg3 = static_cast< Real >(val3);
  {
    try {
      (arg1)->add((Array const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_add__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  Array *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Array temp2 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipleIncrementalStatistics_add" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    if (ArrayFromSequence(swig_obj[1],&temp2)) {
      arg2 = &temp2;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Array,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "Array const &""'");
      }
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipleIncrementalStatistics_add" "', argument " "2"" of type '" "Array const &""'"); 
      }
      arg2 = reinterpret_cast< Array * >(argp2);
    }
  }
  {
    try {
      (arg1)->add((Array const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipleIncrementalStatistics_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MultipleIncrementalStatistics_add", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultipleIncrementalStatistics_add__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        return _wrap_MultipleIncrementalStatistics_add__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MultipleIncrementalStatistics_add__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        /* native sequence? */
        if (PyTuple_Check(argv[1]) || PyList_Check(argv[1])) {
          Size size = PySequence_Size(argv[1]);
          if (size == 0) {
            _v = 1;
          } else {
            PyObject* o = PySequence_GetItem(argv[1],0);
            if (PyNumber_Check(o))
            _v = 1;
            else
            _v = 0;
            Py_DECREF(o);
          }
        } else {
          // copied from SWIGTYPE typemap -- might need updating for newer SWIG
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Array, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MultipleIncrementalStatistics_add__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MultipleIncrementalStatistics_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    GenericSequenceStatistics< IncrementalStatistics >::add(std::vector< Real,std::allocator< Real > > const &,Real)\n"
    "    GenericSequenceStatistics< IncrementalStatistics >::add(std::vector< Real,std::allocator< Real > > const &)\n"
    "    GenericSequenceStatistics< IncrementalStatistics >::add(Array const &,Real)\n"
    "    GenericSequenceStatistics< IncrementalStatistics >::add(Array const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultipleIncrementalStatistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GenericSequenceStatistics< IncrementalStatistics > *arg1 = (GenericSequenceStatistics< IncrementalStatistics > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultipleIncrementalStatistics" "', argument " "1"" of type '" "GenericSequenceStatistics< IncrementalStatistics > *""'"); 
  }
  arg1 = reinterpret_cast< GenericSequenceStatistics< IncrementalStatistics > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultipleIncrementalStatistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GenericSequenceStatisticsT_IncrementalStatistics_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MultipleIncrementalStatistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(arg1)->volatility((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Volatility)(arg1)->volatility((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Volatility)(arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructure_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Volatility)(arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructure_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CapFloorTermVolatilityStructure_volatility", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CapFloorTermVolatilityStructure_volatility__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CapFloorTermVolatilityStructure_volatility__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CapFloorTermVolatilityStructure_volatility__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloorTermVolatilityStructure_volatility__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloorTermVolatilityStructure_volatility__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloorTermVolatilityStructure_volatility__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CapFloorTermVolatilityStructure_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CapFloorTermVolatilityStructure::volatility(Period const &,Rate,bool)\n"
    "    CapFloorTermVolatilityStructure::volatility(Period const &,Rate)\n"
    "    CapFloorTermVolatilityStructure::volatility(Date const &,Rate,bool)\n"
    "    CapFloorTermVolatilityStructure::volatility(Date const &,Rate)\n"
    "    CapFloorTermVolatilityStructure::volatility(Time,Rate,bool)\n"
    "    CapFloorTermVolatilityStructure::volatility(Time,Rate)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CapFloorTermVolatilityStructure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolatilityStructure *arg1 = (CapFloorTermVolatilityStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapFloorTermVolatilityStructure" "', argument " "1"" of type '" "CapFloorTermVolatilityStructure *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = const_cast< CapFloorTermVolatilityStructure * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CapFloorTermVolatilityStructure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CapFloorTermVolatilityStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  Handle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolatilityStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< CapFloorTermVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (Handle< CapFloorTermVolatilityStructure > *)new Handle< CapFloorTermVolatilityStructure >((ext::shared_ptr< CapFloorTermVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolatilityStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (Handle< CapFloorTermVolatilityStructure > *)new Handle< CapFloorTermVolatilityStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolatilityStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CapFloorTermVolatilityStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CapFloorTermVolatilityStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CapFloorTermVolatilityStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CapFloorTermVolatilityStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Handle< CapFloorTermVolatilityStructure >::Handle(ext::shared_ptr< CapFloorTermVolatilityStructure > const &)\n"
    "    Handle< CapFloorTermVolatilityStructure >::Handle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle___deref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle___deref__" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (arg1)->operator ->();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolatilityStructure > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolatilityStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_currentLink(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_currentLink" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (arg1)->currentLink();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolatilityStructure > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolatilityStructure >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle___nonzero__" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_CapFloorTermVolatilityStructure_Sg____nonzero__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle___bool__" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)Handle_Sl_CapFloorTermVolatilityStructure_Sg____bool__(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_asObservable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< Observable > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_asObservable" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = Handle_Sl_CapFloorTermVolatilityStructure_Sg__asObservable(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Observable > *smartresult = result ? new ext::shared_ptr<  Observable >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Observable_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CapFloorTermVolatilityStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapFloorTermVolatilityStructureHandle" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Period *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Period,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Period const &""'"); 
  }
  arg2 = reinterpret_cast< Period * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Period const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility((Date const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Time arg2 ;
  Rate arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  Volatility result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "2"" of type '" "Time""'");
  } 
  arg2 = static_cast< Time >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CapFloorTermVolatilityStructureHandle_volatility" "', argument " "3"" of type '" "Rate""'");
  } 
  arg3 = static_cast< Rate >(val3);
  {
    try {
      result = (Volatility)(*arg1)->volatility(arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_volatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CapFloorTermVolatilityStructureHandle_volatility", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_5(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Period, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapFloorTermVolatilityStructureHandle_volatility__SWIG_4(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CapFloorTermVolatilityStructureHandle_volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CapFloorTermVolatilityStructure::volatility(Period const &,Rate,bool)\n"
    "    CapFloorTermVolatilityStructure::volatility(Period const &,Rate)\n"
    "    CapFloorTermVolatilityStructure::volatility(Date const &,Rate,bool)\n"
    "    CapFloorTermVolatilityStructure::volatility(Date const &,Rate)\n"
    "    CapFloorTermVolatilityStructure::volatility(Time,Rate,bool)\n"
    "    CapFloorTermVolatilityStructure::volatility(Time,Rate)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_minStrike" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_maxStrike" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (Real)(*arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_dayCounter" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_timeFromReference(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  Date *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  Time result;
  
  if (!SWIG_Python_UnpackTuple(args, "CapFloorTermVolatilityStructureHandle_timeFromReference", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_timeFromReference" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CapFloorTermVolatilityStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CapFloorTermVolatilityStructureHandle_timeFromReference" "', argument " "2"" of type '" "Date const &""'"); 
  }
  arg2 = reinterpret_cast< Date * >(argp2);
  {
    try {
      result = (Time)(*arg1)->timeFromReference((Date const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_calendar" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_referenceDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_referenceDate" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->referenceDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_maxDate" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (*arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_maxTime(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  Time result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_maxTime" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > const *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (Time)(*arg1)->maxTime();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_enableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_enableExtrapolation" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      (*arg1)->enableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_disableExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_disableExtrapolation" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      (*arg1)->disableExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolatilityStructureHandle_allowsExtrapolation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Handle< CapFloorTermVolatilityStructure > *arg1 = (Handle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolatilityStructureHandle_allowsExtrapolation" "', argument " "1"" of type '" "Handle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< Handle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      result = (bool)(*arg1)->allowsExtrapolation();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CapFloorTermVolatilityStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_HandleT_CapFloorTermVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CapFloorTermVolatilityStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_RelinkableCapFloorTermVolatilityStructureHandle__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared1 ;
  RelinkableHandle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelinkableCapFloorTermVolatilityStructureHandle" "', argument " "1"" of type '" "ext::shared_ptr< CapFloorTermVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (RelinkableHandle< CapFloorTermVolatilityStructure > *)new RelinkableHandle< CapFloorTermVolatilityStructure >((ext::shared_ptr< CapFloorTermVolatilityStructure > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableCapFloorTermVolatilityStructureHandle__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  RelinkableHandle< CapFloorTermVolatilityStructure > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (RelinkableHandle< CapFloorTermVolatilityStructure > *)new RelinkableHandle< CapFloorTermVolatilityStructure >();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelinkableCapFloorTermVolatilityStructureHandle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_RelinkableCapFloorTermVolatilityStructureHandle", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_RelinkableCapFloorTermVolatilityStructureHandle__SWIG_1(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelinkableCapFloorTermVolatilityStructureHandle__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RelinkableCapFloorTermVolatilityStructureHandle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    RelinkableHandle< CapFloorTermVolatilityStructure >::RelinkableHandle(ext::shared_ptr< CapFloorTermVolatilityStructure > const &)\n"
    "    RelinkableHandle< CapFloorTermVolatilityStructure >::RelinkableHandle()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RelinkableCapFloorTermVolatilityStructureHandle_linkTo(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< CapFloorTermVolatilityStructure > *arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *) 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< CapFloorTermVolatilityStructure > tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "RelinkableCapFloorTermVolatilityStructureHandle_linkTo", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableCapFloorTermVolatilityStructureHandle_linkTo" "', argument " "1"" of type '" "RelinkableHandle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RelinkableCapFloorTermVolatilityStructureHandle_linkTo" "', argument " "2"" of type '" "ext::shared_ptr< CapFloorTermVolatilityStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< CapFloorTermVolatilityStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->linkTo((ext::shared_ptr< CapFloorTermVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RelinkableCapFloorTermVolatilityStructureHandle_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< CapFloorTermVolatilityStructure > *arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RelinkableCapFloorTermVolatilityStructureHandle_reset" "', argument " "1"" of type '" "RelinkableHandle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      RelinkableHandle_Sl_CapFloorTermVolatilityStructure_Sg__reset(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RelinkableCapFloorTermVolatilityStructureHandle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  RelinkableHandle< CapFloorTermVolatilityStructure > *arg1 = (RelinkableHandle< CapFloorTermVolatilityStructure > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelinkableCapFloorTermVolatilityStructureHandle" "', argument " "1"" of type '" "RelinkableHandle< CapFloorTermVolatilityStructure > *""'"); 
  }
  arg1 = reinterpret_cast< RelinkableHandle< CapFloorTermVolatilityStructure > * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RelinkableCapFloorTermVolatilityStructureHandle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_RelinkableHandleT_CapFloorTermVolatilityStructure_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *RelinkableCapFloorTermVolatilityStructureHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CapFloorTermVolCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  CapFloorTermVolCurve *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolCurve" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolCurve" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolCurve > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  CapFloorTermVolCurve *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolCurve" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolCurve > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg5 = 0 ;
  DayCounter *arg6 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  CapFloorTermVolCurve *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CapFloorTermVolCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolCurve" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolCurve" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "6"" of type '" "DayCounter const &""'"); 
  }
  arg6 = reinterpret_cast< DayCounter * >(argp6);
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg5,(DayCounter const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolCurve > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Volatility,std::allocator< Volatility > > *arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  CapFloorTermVolCurve *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CapFloorTermVolCurve" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolCurve" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolCurve" "', argument " "5"" of type '" "std::vector< Volatility,std::allocator< Volatility > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    try {
      result = (CapFloorTermVolCurve *)new CapFloorTermVolCurve(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Volatility,std::allocator< Volatility > > const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolCurve > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolCurve >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CapFloorTermVolCurve", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CapFloorTermVolCurve__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CapFloorTermVolCurve__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CapFloorTermVolCurve__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CapFloorTermVolCurve__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CapFloorTermVolCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CapFloorTermVolCurve::CapFloorTermVolCurve(Date const &,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Volatility,std::allocator< Volatility > > const &,DayCounter const &)\n"
    "    CapFloorTermVolCurve::CapFloorTermVolCurve(Date const &,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Volatility,std::allocator< Volatility > > const &)\n"
    "    CapFloorTermVolCurve::CapFloorTermVolCurve(Natural,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Volatility,std::allocator< Volatility > > const &,DayCounter const &)\n"
    "    CapFloorTermVolCurve::CapFloorTermVolCurve(Natural,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Volatility,std::allocator< Volatility > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CapFloorTermVolCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolCurve *arg1 = (CapFloorTermVolCurve *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolCurve > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolCurve > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapFloorTermVolCurve" "', argument " "1"" of type '" "CapFloorTermVolCurve *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolCurve > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolCurve > * >(argp1);
      arg1 = const_cast< CapFloorTermVolCurve * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolCurve > * >(argp1);
      arg1 = const_cast< CapFloorTermVolCurve * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CapFloorTermVolCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolCurve_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CapFloorTermVolCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg6 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Date *arg1 = 0 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Date,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Date const &""'"); 
  }
  arg1 = reinterpret_cast< Date * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface((Date const &)*arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(Matrix const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  DayCounter *arg7 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "7"" of type '" "DayCounter const &""'"); 
  }
  arg7 = reinterpret_cast< DayCounter * >(argp7);
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(Matrix const &)*arg6,(DayCounter const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  std::vector< Period,std::allocator< Period > > *arg4 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg5 = 0 ;
  Matrix *arg6 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  Matrix temp6 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  CapFloorTermVolSurface *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CapFloorTermVolSurface" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CapFloorTermVolSurface" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    std::vector< Period,std::allocator< Period > > *ptr = (std::vector< Period,std::allocator< Period > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "4"" of type '" "std::vector< Period,std::allocator< Period > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res5 = swig::asptr(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "5"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    if (PyTuple_Check(swig_obj[5]) || PyList_Check(swig_obj[5])) {
      Size rows, cols;
      rows = (PyTuple_Check(swig_obj[5]) ?
      PyTuple_Size(swig_obj[5]) :
        PyList_Size(swig_obj[5]));
      if (rows > 0) {
        // look ahead
        PyObject* o = PySequence_GetItem(swig_obj[5],0);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          cols = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      } else {
        cols = 0;
      }
      
      temp6 = Matrix(rows,cols);
      for (Size i=0; i<rows; i++) {
        PyObject* o = PySequence_GetItem(swig_obj[5],i);
        if (PyTuple_Check(o) || PyList_Check(o)) {
          Size items = (PyTuple_Check(o) ?
          PyTuple_Size(o) :
            PyList_Size(o));
          if (items != cols) {
            PyErr_SetString(PyExc_TypeError,
              "Matrix must have equal-length rows");
            Py_DECREF(o);
            SWIG_fail;
          }
          for (Size j=0; j<cols; j++) {
            PyObject* d = PySequence_GetItem(o,j);
            if (PyFloat_Check(d)) {
              temp6[i][j] = PyFloat_AsDouble(d);
              Py_DECREF(d);
            } else if (PyInt_Check(d)) {
              temp6[i][j] = Real(PyInt_AsLong(d));
              Py_DECREF(d);
            } else {
              PyErr_SetString(PyExc_TypeError,"doubles expected");
              Py_DECREF(d);
              Py_DECREF(o);
              SWIG_fail;
            }
          }
          Py_DECREF(o);
        } else {
          PyErr_SetString(PyExc_TypeError, "Matrix expected");
          Py_DECREF(o);
          SWIG_fail;
        }
      }
      arg6 = &temp6;
    } else {
      // copied from SWIGTYPE typemap -- might need updating for newer SWIG
      res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Matrix,  0 );
      if (!SWIG_IsOK(res6)) {
        SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'");
      }
      if (!argp6) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapFloorTermVolSurface" "', argument " "6"" of type '" "Matrix const &""'"); 
      }
      arg6 = reinterpret_cast< Matrix * >(argp6);
    }
  }
  {
    try {
      result = (CapFloorTermVolSurface *)new CapFloorTermVolSurface(arg1,(Calendar const &)*arg2,arg3,(std::vector< Period,std::allocator< Period > > const &)*arg4,(std::vector< Rate,std::allocator< Rate > > const &)*arg5,(Matrix const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  CapFloorTermVolSurface > *smartresult = result ? new ext::shared_ptr<  CapFloorTermVolSurface >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapFloorTermVolSurface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CapFloorTermVolSurface", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CapFloorTermVolSurface__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                return _wrap_new_CapFloorTermVolSurface__SWIG_5(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_CapFloorTermVolSurface__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                return _wrap_new_CapFloorTermVolSurface__SWIG_7(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CapFloorTermVolSurface__SWIG_2(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Date, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CapFloorTermVolSurface__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CapFloorTermVolSurface__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Period,std::allocator< Period > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                /* native sequence? */
                if (PyTuple_Check(argv[5]) || PyList_Check(argv[5])) {
                  _v = 1;
                  /* wrapped Matrix? */
                } else {
                  // copied from SWIGTYPE typemap -- might need updating for newer SWIG
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Matrix, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_CapFloorTermVolSurface__SWIG_6(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CapFloorTermVolSurface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Natural,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,DayCounter const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Natural,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Date const &,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &,DayCounter const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Date const &,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Date const &,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,Matrix const &,DayCounter const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Date const &,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,Matrix const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Natural,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,Matrix const &,DayCounter const &)\n"
    "    CapFloorTermVolSurface::CapFloorTermVolSurface(Natural,Calendar const &,BusinessDayConvention,std::vector< Period,std::allocator< Period > > const &,std::vector< Rate,std::allocator< Rate > > const &,Matrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_maxDate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Date result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_maxDate" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((CapFloorTermVolSurface const *)arg1)->maxDate();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Date(result)), SWIGTYPE_p_Date, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_minStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_minStrike" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CapFloorTermVolSurface const *)arg1)->minStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_maxStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_maxStrike" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)((CapFloorTermVolSurface const *)arg1)->maxStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_optionTenors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Period,std::allocator< Period > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_optionTenors" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Period,std::allocator< Period > > *) &((CapFloorTermVolSurface const *)arg1)->optionTenors();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Period,std::allocator< Period > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_optionDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_optionDates" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((CapFloorTermVolSurface const *)arg1)->optionDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_optionTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_optionTimes" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((CapFloorTermVolSurface const *)arg1)->optionTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CapFloorTermVolSurface_strikes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface const > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CapFloorTermVolSurface_strikes" "', argument " "1"" of type '" "CapFloorTermVolSurface const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((CapFloorTermVolSurface const *)arg1)->strikes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CapFloorTermVolSurface(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  CapFloorTermVolSurface *arg1 = (CapFloorTermVolSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempshared1 ;
  ext::shared_ptr< CapFloorTermVolSurface > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapFloorTermVolSurface" "', argument " "1"" of type '" "CapFloorTermVolSurface *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  CapFloorTermVolSurface > * >(argp1);
      arg1 = const_cast< CapFloorTermVolSurface * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CapFloorTermVolSurface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CapFloorTermVolSurface_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StrippedOptionletBase_optionletStrikes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrippedOptionletBase_optionletStrikes", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_optionletStrikes" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrippedOptionletBase_optionletStrikes" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &(arg1)->optionletStrikes(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_optionletVolatilities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  Size arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< Volatility,std::allocator< Volatility > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "StrippedOptionletBase_optionletVolatilities", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_optionletVolatilities" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrippedOptionletBase_optionletVolatilities" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (std::vector< Volatility,std::allocator< Volatility > > *) &(arg1)->optionletVolatilities(arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_optionletFixingDates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_optionletFixingDates" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &(arg1)->optionletFixingDates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_optionletFixingTimes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_optionletFixingTimes" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &(arg1)->optionletFixingTimes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_optionletMaturities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Size result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_optionletMaturities" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->optionletMaturities();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_atmOptionletRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_atmOptionletRates" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &(arg1)->atmOptionletRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_dayCounter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< DayCounter > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_dayCounter" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->dayCounter();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new DayCounter(result)), SWIGTYPE_p_DayCounter, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_calendar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< Calendar > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_calendar" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->calendar();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new Calendar(result)), SWIGTYPE_p_Calendar, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_settlementDays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Natural result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_settlementDays" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Natural)(arg1)->settlementDays();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_businessDayConvention(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  BusinessDayConvention result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_businessDayConvention" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (BusinessDayConvention)(arg1)->businessDayConvention();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_volatilityType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  VolatilityType result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_volatilityType" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (VolatilityType)(arg1)->volatilityType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StrippedOptionletBase_displacement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrippedOptionletBase_displacement" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)(arg1)->displacement();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StrippedOptionletBase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletBase *arg1 = (StrippedOptionletBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  ext::shared_ptr< StrippedOptionletBase > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrippedOptionletBase" "', argument " "1"" of type '" "StrippedOptionletBase *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletBase > * >(argp1);
      arg1 = const_cast< StrippedOptionletBase * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrippedOptionletBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StrippedOptionlet(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Natural arg1 ;
  Calendar *arg2 = 0 ;
  BusinessDayConvention arg3 ;
  ext::shared_ptr< IborIndex > arg4 ;
  std::vector< Date,std::allocator< Date > > *arg5 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg6 = 0 ;
  std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > arg7 ;
  SwigValueWrapper< DayCounter > arg8 ;
  VolatilityType arg9 = (VolatilityType) ShiftedLognormal ;
  Real arg10 = (Real) 0.0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"settlementDays",  (char *)"calendar",  (char *)"bdc",  (char *)"iborIndex",  (char *)"optionletDates",  (char *)"strikes",  (char *)"volatilities",  (char *)"dc",  (char *)"type",  (char *)"displacement",  NULL 
  };
  StrippedOptionlet *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO|OO:new_StrippedOptionlet", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StrippedOptionlet" "', argument " "1"" of type '" "Natural""'");
  } 
  arg1 = static_cast< Natural >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StrippedOptionlet" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrippedOptionlet" "', argument " "2"" of type '" "Calendar const &""'"); 
  }
  arg2 = reinterpret_cast< Calendar * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StrippedOptionlet" "', argument " "3"" of type '" "BusinessDayConvention""'");
  } 
  arg3 = static_cast< BusinessDayConvention >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(obj3, &argp4, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_StrippedOptionlet" "', argument " "4"" of type '" "ext::shared_ptr< IborIndex >""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp4);
  }
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res5 = swig::asptr(obj4, &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_StrippedOptionlet" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrippedOptionlet" "', argument " "5"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg5 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res6 = swig::asptr(obj5, &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_StrippedOptionlet" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrippedOptionlet" "', argument " "6"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *ptr = (std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > > *)0;
    int res = swig::asptr(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_StrippedOptionlet" "', argument " "7"" of type '" "std::vector< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > >,std::allocator< std::vector< Handle< Quote >,std::allocator< Handle< Quote > > > > >""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_DayCounter,  0  | 0);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_StrippedOptionlet" "', argument " "8"" of type '" "DayCounter""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrippedOptionlet" "', argument " "8"" of type '" "DayCounter""'");
    } else {
      DayCounter * temp = reinterpret_cast< DayCounter * >(argp8);
      arg8 = *temp;
      if (SWIG_IsNewObj(res8)) delete temp;
    }
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_StrippedOptionlet" "', argument " "9"" of type '" "VolatilityType""'");
    } 
    arg9 = static_cast< VolatilityType >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_double(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_StrippedOptionlet" "', argument " "10"" of type '" "Real""'");
    } 
    arg10 = static_cast< Real >(val10);
  }
  {
    try {
      result = (StrippedOptionlet *)new StrippedOptionlet(arg1,(Calendar const &)*arg2,arg3,arg4,(std::vector< Date,std::allocator< Date > > const &)*arg5,(std::vector< Rate,std::allocator< Rate > > const &)*arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StrippedOptionlet > *smartresult = result ? new ext::shared_ptr<  StrippedOptionlet >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StrippedOptionlet_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StrippedOptionlet(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionlet *arg1 = (StrippedOptionlet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionlet > tempshared1 ;
  ext::shared_ptr< StrippedOptionlet > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionlet_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrippedOptionlet" "', argument " "1"" of type '" "StrippedOptionlet *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionlet > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionlet > * >(argp1);
      arg1 = const_cast< StrippedOptionlet * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionlet > * >(argp1);
      arg1 = const_cast< StrippedOptionlet * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrippedOptionlet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StrippedOptionlet_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StrippedOptionlet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_OptionletStripper1(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  ext::shared_ptr< CapFloorTermVolSurface > *arg1 = 0 ;
  ext::shared_ptr< IborIndex > *arg2 = 0 ;
  Rate arg3 = (Rate) Null< Rate >() ;
  Real arg4 = (Real) 1.0e-6 ;
  Natural arg5 = (Natural) 100 ;
  Handle< YieldTermStructure > const &arg6_defvalue = Handle< YieldTermStructure >() ;
  Handle< YieldTermStructure > *arg6 = (Handle< YieldTermStructure > *) &arg6_defvalue ;
  VolatilityType arg7 = (VolatilityType) ShiftedLognormal ;
  Real arg8 = (Real) 0.0 ;
  bool arg9 = (bool) false ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< CapFloorTermVolSurface > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< IborIndex > tempshared2 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"parVolSurface",  (char *)"index",  (char *)"switchStrikes",  (char *)"accuracy",  (char *)"maxIter",  (char *)"discount",  (char *)"type",  (char *)"displacement",  (char *)"dontThrow",  NULL 
  };
  OptionletStripper1 *result = 0 ;
  
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOOOOOO:new_OptionletStripper1", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(obj0, &argp1, SWIGTYPE_p_ext__shared_ptrT_CapFloorTermVolSurface_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptionletStripper1" "', argument " "1"" of type '" "ext::shared_ptr< CapFloorTermVolSurface > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< CapFloorTermVolSurface > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< CapFloorTermVolSurface > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< CapFloorTermVolSurface > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(obj1, &argp2, SWIGTYPE_p_ext__shared_ptrT_IborIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OptionletStripper1" "', argument " "2"" of type '" "ext::shared_ptr< IborIndex > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< IborIndex > * >(argp2) : &tempshared2;
    }
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_double(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OptionletStripper1" "', argument " "3"" of type '" "Rate""'");
    } 
    arg3 = static_cast< Rate >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_double(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OptionletStripper1" "', argument " "4"" of type '" "Real""'");
    } 
    arg4 = static_cast< Real >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_OptionletStripper1" "', argument " "5"" of type '" "Natural""'");
    } 
    arg5 = static_cast< Natural >(val5);
  }
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_OptionletStripper1" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
    }
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptionletStripper1" "', argument " "6"" of type '" "Handle< YieldTermStructure > const &""'"); 
    }
    arg6 = reinterpret_cast< Handle< YieldTermStructure > * >(argp6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_OptionletStripper1" "', argument " "7"" of type '" "VolatilityType""'");
    } 
    arg7 = static_cast< VolatilityType >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_double(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_OptionletStripper1" "', argument " "8"" of type '" "Real""'");
    } 
    arg8 = static_cast< Real >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_bool(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_OptionletStripper1" "', argument " "9"" of type '" "bool""'");
    } 
    arg9 = static_cast< bool >(val9);
  }
  {
    try {
      result = (OptionletStripper1 *)new OptionletStripper1((ext::shared_ptr< CapFloorTermVolSurface > const &)*arg1,(ext::shared_ptr< IborIndex > const &)*arg2,arg3,arg4,arg5,(Handle< YieldTermStructure > const &)*arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  OptionletStripper1 > *smartresult = result ? new ext::shared_ptr<  OptionletStripper1 >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletStripper1_capFloorPrices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletStripper1 const > tempshared1 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletStripper1_capFloorPrices" "', argument " "1"" of type '" "OptionletStripper1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Matrix *) &((OptionletStripper1 const *)arg1)->capFloorPrices();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletStripper1_capFloorVolatilities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletStripper1 const > tempshared1 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletStripper1_capFloorVolatilities" "', argument " "1"" of type '" "OptionletStripper1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Matrix *) &((OptionletStripper1 const *)arg1)->capFloorVolatilities();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletStripper1_optionletPrices(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletStripper1 const > tempshared1 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Matrix *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletStripper1_optionletPrices" "', argument " "1"" of type '" "OptionletStripper1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Matrix *) &((OptionletStripper1 const *)arg1)->optionletPrices();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Matrix, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OptionletStripper1_switchStrike(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletStripper1 const > tempshared1 ;
  ext::shared_ptr< OptionletStripper1 const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Rate result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptionletStripper1_switchStrike" "', argument " "1"" of type '" "OptionletStripper1 const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Rate)((OptionletStripper1 const *)arg1)->switchStrike();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OptionletStripper1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  OptionletStripper1 *arg1 = (OptionletStripper1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< OptionletStripper1 > tempshared1 ;
  ext::shared_ptr< OptionletStripper1 > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptionletStripper1" "', argument " "1"" of type '" "OptionletStripper1 *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  OptionletStripper1 > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  OptionletStripper1 > * >(argp1);
      arg1 = const_cast< OptionletStripper1 * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptionletStripper1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_OptionletStripper1_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *OptionletStripper1_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_StrippedOptionletAdapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< StrippedOptionletBase > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletBase > tempshared1 ;
  PyObject *swig_obj[1] ;
  StrippedOptionletAdapter *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletBase_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrippedOptionletAdapter" "', argument " "1"" of type '" "ext::shared_ptr< StrippedOptionletBase > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< StrippedOptionletBase > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< StrippedOptionletBase > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< StrippedOptionletBase > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (StrippedOptionletAdapter *)new StrippedOptionletAdapter((ext::shared_ptr< StrippedOptionletBase > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  StrippedOptionletAdapter > *smartresult = result ? new ext::shared_ptr<  StrippedOptionletAdapter >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletAdapter_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StrippedOptionletAdapter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  StrippedOptionletAdapter *arg1 = (StrippedOptionletAdapter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< StrippedOptionletAdapter > tempshared1 ;
  ext::shared_ptr< StrippedOptionletAdapter > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletAdapter_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrippedOptionletAdapter" "', argument " "1"" of type '" "StrippedOptionletAdapter *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  StrippedOptionletAdapter > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  StrippedOptionletAdapter > * >(argp1);
      arg1 = const_cast< StrippedOptionletAdapter * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  StrippedOptionletAdapter > * >(argp1);
      arg1 = const_cast< StrippedOptionletAdapter * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrippedOptionletAdapter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_StrippedOptionletAdapter_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StrippedOptionletAdapter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Settlement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settlement *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_Settlement", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (Settlement *)new Settlement();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Settlement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Settlement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Settlement *arg1 = (Settlement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Settlement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Settlement" "', argument " "1"" of type '" "Settlement *""'"); 
  }
  arg1 = reinterpret_cast< Settlement * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Settlement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Settlement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Settlement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_Swaption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VanillaSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  Settlement::Method arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Swaption *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Swaption" "', argument " "1"" of type '" "ext::shared_ptr< VanillaSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Swaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Swaption" "', argument " "3"" of type '" "Settlement::Type""'");
  } 
  arg3 = static_cast< Settlement::Type >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Swaption" "', argument " "4"" of type '" "Settlement::Method""'");
  } 
  arg4 = static_cast< Settlement::Method >(val4);
  {
    try {
      result = (Swaption *)new Swaption((ext::shared_ptr< VanillaSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swaption > *smartresult = result ? new ext::shared_ptr<  Swaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swaption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VanillaSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  Swaption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Swaption" "', argument " "1"" of type '" "ext::shared_ptr< VanillaSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Swaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Swaption" "', argument " "3"" of type '" "Settlement::Type""'");
  } 
  arg3 = static_cast< Settlement::Type >(val3);
  {
    try {
      result = (Swaption *)new Swaption((ext::shared_ptr< VanillaSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swaption > *smartresult = result ? new ext::shared_ptr<  Swaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swaption__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< VanillaSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  Swaption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Swaption" "', argument " "1"" of type '" "ext::shared_ptr< VanillaSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< VanillaSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Swaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (Swaption *)new Swaption((ext::shared_ptr< VanillaSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  Swaption > *smartresult = result ? new ext::shared_ptr<  Swaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_Swaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Swaption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_Swaption", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Swaption__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Swaption__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Swaption__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Swaption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Swaption::Swaption(ext::shared_ptr< VanillaSwap > const &,ext::shared_ptr< Exercise > const &,Settlement::Type,Settlement::Method)\n"
    "    Swaption::Swaption(ext::shared_ptr< VanillaSwap > const &,ext::shared_ptr< Exercise > const &,Settlement::Type)\n"
    "    Swaption::Swaption(ext::shared_ptr< VanillaSwap > const &,ext::shared_ptr< Exercise > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Swaption_settlementType(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Settlement::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_settlementType" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Settlement::Type)((Swaption const *)arg1)->settlementType();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_settlementMethod(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Settlement::Method result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_settlementMethod" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Settlement::Method)((Swaption const *)arg1)->settlementMethod();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  VanillaSwap::Type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_type" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (VanillaSwap::Type)((Swaption const *)arg1)->type();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_underlyingSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< VanillaSwap > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_underlyingSwap" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< VanillaSwap > *) &((Swaption const *)arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwap > *smartresult = *result ? new ext::shared_ptr<  VanillaSwap >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  Volatility result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Swaption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Swaption_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Swaption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Swaption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Swaption_impliedVolatility" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Swaption_impliedVolatility" "', argument " "10"" of type '" "Real""'");
  } 
  arg10 = static_cast< Real >(val10);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  VolatilityType arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Volatility result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Swaption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Swaption_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Swaption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Swaption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Swaption_impliedVolatility" "', argument " "9"" of type '" "VolatilityType""'");
  } 
  arg9 = static_cast< VolatilityType >(val9);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  Volatility arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  Volatility result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Swaption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Swaption_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Swaption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Swaption_impliedVolatility" "', argument " "8"" of type '" "Volatility""'");
  } 
  arg8 = static_cast< Volatility >(val8);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  Volatility arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  Volatility result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Swaption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Swaption_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Swaption_impliedVolatility" "', argument " "7"" of type '" "Volatility""'");
  } 
  arg7 = static_cast< Volatility >(val7);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  Natural arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  Volatility result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Swaption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Swaption_impliedVolatility" "', argument " "6"" of type '" "Natural""'");
  } 
  arg6 = static_cast< Natural >(val6);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  Volatility result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Swaption_impliedVolatility" "', argument " "5"" of type '" "Real""'");
  } 
  arg5 = static_cast< Real >(val5);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4,arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  Real arg2 ;
  Handle< YieldTermStructure > *arg3 = 0 ;
  Volatility arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption const > tempshared1 ;
  ext::shared_ptr< Swaption const > *smartarg1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  Volatility result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_impliedVolatility" "', argument " "1"" of type '" "Swaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Swaption_impliedVolatility" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Swaption_impliedVolatility" "', argument " "3"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg3 = reinterpret_cast< Handle< YieldTermStructure > * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Swaption_impliedVolatility" "', argument " "4"" of type '" "Volatility""'");
  } 
  arg4 = static_cast< Volatility >(val4);
  {
    try {
      result = (Volatility)((Swaption const *)arg1)->impliedVolatility(arg2,(Handle< YieldTermStructure > const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_impliedVolatility(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "Swaption_impliedVolatility", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Swaption_impliedVolatility__SWIG_6(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Swaption_impliedVolatility__SWIG_5(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Swaption_impliedVolatility__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Swaption_impliedVolatility__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Swaption_impliedVolatility__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Swaption_impliedVolatility__SWIG_1(self, argc, argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Swaption_impliedVolatility__SWIG_0(self, argc, argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Swaption_impliedVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility,Volatility,VolatilityType,Real) const\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility,Volatility,VolatilityType) const\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility,Volatility) const\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural,Volatility) const\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real,Natural) const\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility,Real) const\n"
    "    Swaption::impliedVolatility(Real,Handle< YieldTermStructure > const &,Volatility) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Swaption_vega(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption > tempshared1 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_vega" "', argument " "1"" of type '" "Swaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)Swaption_vega(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_delta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption > tempshared1 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_delta" "', argument " "1"" of type '" "Swaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)Swaption_delta(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Swaption_annuity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption > tempshared1 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Swaption_annuity" "', argument " "1"" of type '" "Swaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)Swaption_annuity(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Swaption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Swaption *arg1 = (Swaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< Swaption > tempshared1 ;
  ext::shared_ptr< Swaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Swaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Swaption" "', argument " "1"" of type '" "Swaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  Swaption > * >(argp1);
      arg1 = const_cast< Swaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Swaption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_Swaption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *Swaption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NonstandardSwaption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< NonstandardSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  Settlement::Method arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  NonstandardSwaption *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonstandardSwaption" "', argument " "1"" of type '" "ext::shared_ptr< NonstandardSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NonstandardSwaption" "', argument " "3"" of type '" "Settlement::Type""'");
  } 
  arg3 = static_cast< Settlement::Type >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_NonstandardSwaption" "', argument " "4"" of type '" "Settlement::Method""'");
  } 
  arg4 = static_cast< Settlement::Method >(val4);
  {
    try {
      result = (NonstandardSwaption *)new NonstandardSwaption((ext::shared_ptr< NonstandardSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwaption > *smartresult = result ? new ext::shared_ptr<  NonstandardSwaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwaption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< NonstandardSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  NonstandardSwaption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonstandardSwaption" "', argument " "1"" of type '" "ext::shared_ptr< NonstandardSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NonstandardSwaption" "', argument " "3"" of type '" "Settlement::Type""'");
  } 
  arg3 = static_cast< Settlement::Type >(val3);
  {
    try {
      result = (NonstandardSwaption *)new NonstandardSwaption((ext::shared_ptr< NonstandardSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwaption > *smartresult = result ? new ext::shared_ptr<  NonstandardSwaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwaption__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< NonstandardSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  NonstandardSwaption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonstandardSwaption" "', argument " "1"" of type '" "ext::shared_ptr< NonstandardSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< NonstandardSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonstandardSwaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (NonstandardSwaption *)new NonstandardSwaption((ext::shared_ptr< NonstandardSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwaption > *smartresult = result ? new ext::shared_ptr<  NonstandardSwaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NonstandardSwaption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NonstandardSwaption", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NonstandardSwaption__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_NonstandardSwaption__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_NonstandardSwaption__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NonstandardSwaption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    NonstandardSwaption::NonstandardSwaption(ext::shared_ptr< NonstandardSwap > const &,ext::shared_ptr< Exercise > const &,Settlement::Type,Settlement::Method)\n"
    "    NonstandardSwaption::NonstandardSwaption(ext::shared_ptr< NonstandardSwap > const &,ext::shared_ptr< Exercise > const &,Settlement::Type)\n"
    "    NonstandardSwaption::NonstandardSwaption(ext::shared_ptr< NonstandardSwap > const &,ext::shared_ptr< Exercise > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NonstandardSwaption_underlyingSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwaption const > tempshared1 ;
  ext::shared_ptr< NonstandardSwaption const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< NonstandardSwap > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwaption_underlyingSwap" "', argument " "1"" of type '" "NonstandardSwaption const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const NonstandardSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< NonstandardSwap > *) &((NonstandardSwaption const *)arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  NonstandardSwap > *smartresult = *result ? new ext::shared_ptr<  NonstandardSwap >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_NonstandardSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwaption_calibrationBasket(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  ext::shared_ptr< SwapIndex > arg2 ;
  ext::shared_ptr< SwaptionVolatilityStructure > arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwaption > tempshared1 ;
  ext::shared_ptr< NonstandardSwaption > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[4] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "NonstandardSwaption_calibrationBasket", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwaption_calibrationBasket" "', argument " "1"" of type '" "NonstandardSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonstandardSwaption_calibrationBasket" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonstandardSwaption_calibrationBasket" "', argument " "3"" of type '" "ext::shared_ptr< SwaptionVolatilityStructure >""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp3);
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "NonstandardSwaption_calibrationBasket" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = NonstandardSwaption_calibrationBasket(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NonstandardSwaption_probabilities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwaption > tempshared1 ;
  ext::shared_ptr< NonstandardSwaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonstandardSwaption_probabilities" "', argument " "1"" of type '" "NonstandardSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = NonstandardSwaption_probabilities(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NonstandardSwaption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  NonstandardSwaption *arg1 = (NonstandardSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< NonstandardSwaption > tempshared1 ;
  ext::shared_ptr< NonstandardSwaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonstandardSwaption" "', argument " "1"" of type '" "NonstandardSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  NonstandardSwaption > * >(argp1);
      arg1 = const_cast< NonstandardSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NonstandardSwaption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_NonstandardSwaption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NonstandardSwaption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FloatFloatSwaption__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FloatFloatSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  Settlement::Method arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  FloatFloatSwaption *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatFloatSwaption" "', argument " "1"" of type '" "ext::shared_ptr< FloatFloatSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatFloatSwaption" "', argument " "3"" of type '" "Settlement::Type""'");
  } 
  arg3 = static_cast< Settlement::Type >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FloatFloatSwaption" "', argument " "4"" of type '" "Settlement::Method""'");
  } 
  arg4 = static_cast< Settlement::Method >(val4);
  {
    try {
      result = (FloatFloatSwaption *)new FloatFloatSwaption((ext::shared_ptr< FloatFloatSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwaption > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwaption__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FloatFloatSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  Settlement::Type arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  int val3 ;
  int ecode3 = 0 ;
  FloatFloatSwaption *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatFloatSwaption" "', argument " "1"" of type '" "ext::shared_ptr< FloatFloatSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatFloatSwaption" "', argument " "3"" of type '" "Settlement::Type""'");
  } 
  arg3 = static_cast< Settlement::Type >(val3);
  {
    try {
      result = (FloatFloatSwaption *)new FloatFloatSwaption((ext::shared_ptr< FloatFloatSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwaption > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwaption__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< FloatFloatSwap > *arg1 = 0 ;
  ext::shared_ptr< Exercise > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwap > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< Exercise > tempshared2 ;
  FloatFloatSwaption *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatFloatSwaption" "', argument " "1"" of type '" "ext::shared_ptr< FloatFloatSwap > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< FloatFloatSwap > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_Exercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatFloatSwaption" "', argument " "2"" of type '" "ext::shared_ptr< Exercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< Exercise > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FloatFloatSwaption *)new FloatFloatSwaption((ext::shared_ptr< FloatFloatSwap > const &)*arg1,(ext::shared_ptr< Exercise > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwaption > *smartresult = result ? new ext::shared_ptr<  FloatFloatSwaption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloatFloatSwaption(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FloatFloatSwaption", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FloatFloatSwaption__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FloatFloatSwaption__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_Exercise_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FloatFloatSwaption__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FloatFloatSwaption'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FloatFloatSwaption::FloatFloatSwaption(ext::shared_ptr< FloatFloatSwap > const &,ext::shared_ptr< Exercise > const &,Settlement::Type,Settlement::Method)\n"
    "    FloatFloatSwaption::FloatFloatSwaption(ext::shared_ptr< FloatFloatSwap > const &,ext::shared_ptr< Exercise > const &,Settlement::Type)\n"
    "    FloatFloatSwaption::FloatFloatSwaption(ext::shared_ptr< FloatFloatSwap > const &,ext::shared_ptr< Exercise > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FloatFloatSwaption_underlyingSwap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwaption > tempshared1 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ext::shared_ptr< FloatFloatSwap > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatSwaption_underlyingSwap" "', argument " "1"" of type '" "FloatFloatSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ext::shared_ptr< FloatFloatSwap > *) &(arg1)->underlyingSwap();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FloatFloatSwap > *smartresult = *result ? new ext::shared_ptr<  FloatFloatSwap >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwap_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatFloatSwaption_calibrationBasket(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  ext::shared_ptr< SwapIndex > arg2 ;
  ext::shared_ptr< SwaptionVolatilityStructure > arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwaption > tempshared1 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[4] ;
  std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "FloatFloatSwaption_calibrationBasket", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatSwaption_calibrationBasket" "', argument " "1"" of type '" "FloatFloatSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwapIndex_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatFloatSwaption_calibrationBasket" "', argument " "2"" of type '" "ext::shared_ptr< SwapIndex >""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SwapIndex > * >(argp2);
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_ext__shared_ptrT_SwaptionVolatilityStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatFloatSwaption_calibrationBasket" "', argument " "3"" of type '" "ext::shared_ptr< SwaptionVolatilityStructure >""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< ext::shared_ptr< SwaptionVolatilityStructure > * >(argp3);
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FloatFloatSwaption_calibrationBasket" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = FloatFloatSwaption_calibrationBasket(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< ext::shared_ptr< BlackCalibrationHelper >,std::allocator< ext::shared_ptr< BlackCalibrationHelper > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatFloatSwaption_underlyingValue(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwaption > tempshared1 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  Real result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatSwaption_underlyingValue" "', argument " "1"" of type '" "FloatFloatSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (Real)FloatFloatSwaption_underlyingValue(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FloatFloatSwaption_probabilities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwaption > tempshared1 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatSwaption_probabilities" "', argument " "1"" of type '" "FloatFloatSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = FloatFloatSwaption_probabilities(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FloatFloatSwaption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FloatFloatSwaption *arg1 = (FloatFloatSwaption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FloatFloatSwaption > tempshared1 ;
  ext::shared_ptr< FloatFloatSwaption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatFloatSwaption" "', argument " "1"" of type '" "FloatFloatSwaption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FloatFloatSwaption > * >(argp1);
      arg1 = const_cast< FloatFloatSwaption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloatFloatSwaption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FloatFloatSwaption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FloatFloatSwaption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BlackSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  BlackSwaptionEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackSwaptionEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BlackSwaptionEngine" "', argument " "4"" of type '" "Real""'");
  } 
  arg4 = static_cast< Real >(val4);
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BlackSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BlackSwaptionEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BlackSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackSwaptionEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BlackSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlackSwaptionEngine" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp2);
  {
    try {
      result = (BlackSwaptionEngine *)new BlackSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BlackSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BlackSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BlackSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlackSwaptionEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BlackSwaptionEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BlackSwaptionEngine__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BlackSwaptionEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_BlackSwaptionEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlackSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BlackSwaptionEngine::BlackSwaptionEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &,DayCounter const &,Real)\n"
    "    BlackSwaptionEngine::BlackSwaptionEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    BlackSwaptionEngine::BlackSwaptionEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &)\n"
    "    BlackSwaptionEngine::BlackSwaptionEngine(Handle< YieldTermStructure > const &,Handle< SwaptionVolatilityStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BlackSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BlackSwaptionEngine *arg1 = (BlackSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BlackSwaptionEngine > tempshared1 ;
  ext::shared_ptr< BlackSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlackSwaptionEngine" "', argument " "1"" of type '" "BlackSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BlackSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BlackSwaptionEngine > * >(argp1);
      arg1 = const_cast< BlackSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BlackSwaptionEngine > * >(argp1);
      arg1 = const_cast< BlackSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BlackSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BlackSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BlackSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_BachelierSwaptionEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  BachelierSwaptionEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BachelierSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BachelierSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BachelierSwaptionEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (BachelierSwaptionEngine *)new BachelierSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BachelierSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BachelierSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BachelierSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BachelierSwaptionEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< Quote > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BachelierSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BachelierSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_Quote_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BachelierSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "2"" of type '" "Handle< Quote > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< Quote > * >(argp2);
  {
    try {
      result = (BachelierSwaptionEngine *)new BachelierSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< Quote > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BachelierSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BachelierSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BachelierSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BachelierSwaptionEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  Handle< YieldTermStructure > *arg1 = 0 ;
  Handle< SwaptionVolatilityStructure > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  BachelierSwaptionEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_HandleT_YieldTermStructure_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BachelierSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "1"" of type '" "Handle< YieldTermStructure > const &""'"); 
  }
  arg1 = reinterpret_cast< Handle< YieldTermStructure > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BachelierSwaptionEngine" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BachelierSwaptionEngine" "', argument " "2"" of type '" "Handle< SwaptionVolatilityStructure > const &""'"); 
  }
  arg2 = reinterpret_cast< Handle< SwaptionVolatilityStructure > * >(argp2);
  {
    try {
      result = (BachelierSwaptionEngine *)new BachelierSwaptionEngine((Handle< YieldTermStructure > const &)*arg1,(Handle< SwaptionVolatilityStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  BachelierSwaptionEngine > *smartresult = result ? new ext::shared_ptr<  BachelierSwaptionEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_BachelierSwaptionEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BachelierSwaptionEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_BachelierSwaptionEngine", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BachelierSwaptionEngine__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_SwaptionVolatilityStructure_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BachelierSwaptionEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HandleT_YieldTermStructure_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HandleT_Quote_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_BachelierSwaptionEngine__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BachelierSwaptionEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    BachelierSwaptionEngine::BachelierSwaptionEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &,DayCounter const &)\n"
    "    BachelierSwaptionEngine::BachelierSwaptionEngine(Handle< YieldTermStructure > const &,Handle< Quote > const &)\n"
    "    BachelierSwaptionEngine::BachelierSwaptionEngine(Handle< YieldTermStructure > const &,Handle< SwaptionVolatilityStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BachelierSwaptionEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  BachelierSwaptionEngine *arg1 = (BachelierSwaptionEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< BachelierSwaptionEngine > tempshared1 ;
  ext::shared_ptr< BachelierSwaptionEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_BachelierSwaptionEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BachelierSwaptionEngine" "', argument " "1"" of type '" "BachelierSwaptionEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  BachelierSwaptionEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  BachelierSwaptionEngine > * >(argp1);
      arg1 = const_cast< BachelierSwaptionEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  BachelierSwaptionEngine > * >(argp1);
      arg1 = const_cast< BachelierSwaptionEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BachelierSwaptionEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_BachelierSwaptionEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *BachelierSwaptionEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_VanillaSwingOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ext::shared_ptr< Payoff > *arg1 = 0 ;
  ext::shared_ptr< SwingExercise > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< Payoff > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< SwingExercise > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  VanillaSwingOption *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_VanillaSwingOption", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_Payoff_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VanillaSwingOption" "', argument " "1"" of type '" "ext::shared_ptr< Payoff > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< Payoff > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_SwingExercise_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VanillaSwingOption" "', argument " "2"" of type '" "ext::shared_ptr< SwingExercise > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< SwingExercise > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< SwingExercise > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< SwingExercise > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VanillaSwingOption" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VanillaSwingOption" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (VanillaSwingOption *)new VanillaSwingOption((ext::shared_ptr< Payoff > const &)*arg1,(ext::shared_ptr< SwingExercise > const &)*arg2,arg3,arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  VanillaSwingOption > *smartresult = result ? new ext::shared_ptr<  VanillaSwingOption >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_VanillaSwingOption_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VanillaSwingOption(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  VanillaSwingOption *arg1 = (VanillaSwingOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< VanillaSwingOption > tempshared1 ;
  ext::shared_ptr< VanillaSwingOption > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_VanillaSwingOption_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VanillaSwingOption" "', argument " "1"" of type '" "VanillaSwingOption *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  VanillaSwingOption > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  VanillaSwingOption > * >(argp1);
      arg1 = const_cast< VanillaSwingOption * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  VanillaSwingOption > * >(argp1);
      arg1 = const_cast< VanillaSwingOption * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VanillaSwingOption_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_VanillaSwingOption_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *VanillaSwingOption_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdSimpleBSSwingEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  FdmSchemeDesc *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "4"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSimpleBSSwingEngine" "', argument " "4"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg4 = reinterpret_cast< FdmSchemeDesc * >(argp4);
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3,(FdmSchemeDesc const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleBSSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleBSSwingEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2,arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleBSSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleBSSwingEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  Size arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "2"" of type '" "Size""'");
  } 
  arg2 = static_cast< Size >(val2);
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleBSSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleBSSwingEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< GeneralizedBlackScholesProcess > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< GeneralizedBlackScholesProcess > tempshared1 ;
  FdSimpleBSSwingEngine *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleBSSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< GeneralizedBlackScholesProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< GeneralizedBlackScholesProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (FdSimpleBSSwingEngine *)new FdSimpleBSSwingEngine((ext::shared_ptr< GeneralizedBlackScholesProcess > const &)*arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleBSSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleBSSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleBSSwingEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdSimpleBSSwingEngine", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FdSimpleBSSwingEngine__SWIG_3(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FdSimpleBSSwingEngine__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdSimpleBSSwingEngine__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FdSimpleBSSwingEngine__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdSimpleBSSwingEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdSimpleBSSwingEngine::FdSimpleBSSwingEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size,FdmSchemeDesc const &)\n"
    "    FdSimpleBSSwingEngine::FdSimpleBSSwingEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size,Size)\n"
    "    FdSimpleBSSwingEngine::FdSimpleBSSwingEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &,Size)\n"
    "    FdSimpleBSSwingEngine::FdSimpleBSSwingEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdSimpleBSSwingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdSimpleBSSwingEngine *arg1 = (FdSimpleBSSwingEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdSimpleBSSwingEngine > tempshared1 ;
  ext::shared_ptr< FdSimpleBSSwingEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdSimpleBSSwingEngine" "', argument " "1"" of type '" "FdSimpleBSSwingEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdSimpleBSSwingEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdSimpleBSSwingEngine > * >(argp1);
      arg1 = const_cast< FdSimpleBSSwingEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdSimpleBSSwingEngine > * >(argp1);
      arg1 = const_cast< FdSimpleBSSwingEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdSimpleBSSwingEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdSimpleBSSwingEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdSimpleBSSwingEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > *arg6 = 0 ;
  FdmSchemeDesc *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "6"" of type '" "std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "6"" of type '" "std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &""'"); 
    }
    arg6 = ptr;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_FdmSchemeDesc,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "7"" of type '" "FdmSchemeDesc const &""'"); 
  }
  arg7 = reinterpret_cast< FdmSchemeDesc * >(argp7);
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),(std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)*arg6,(FdmSchemeDesc const &)*arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
    res6 = swig::asptr(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "6"" of type '" "std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "6"" of type '" "std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &""'"); 
    }
    arg6 = ptr;
  }
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),(std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)*arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res6)) delete arg6;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  Size arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "5"" of type '" "Size""'");
  } 
  arg5 = static_cast< Size >(val5);
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  Size arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "4"" of type '" "Size""'");
  } 
  arg4 = static_cast< Size >(val4);
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  Size arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "3"" of type '" "Size""'");
  } 
  arg3 = static_cast< Size >(val3);
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  ext::shared_ptr< ExtOUWithJumpsProcess > *arg1 = 0 ;
  ext::shared_ptr< YieldTermStructure > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  ext::shared_ptr< ExtOUWithJumpsProcess > tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  ext::shared_ptr< YieldTermStructure > tempshared2 ;
  FdSimpleExtOUJumpSwingEngine *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "ext::shared_ptr< ExtOUWithJumpsProcess > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< ext::shared_ptr< ExtOUWithJumpsProcess > * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FdSimpleExtOUJumpSwingEngine" "', argument " "2"" of type '" "ext::shared_ptr< YieldTermStructure > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      delete reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< ext::shared_ptr< YieldTermStructure > * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (FdSimpleExtOUJumpSwingEngine *)new_FdSimpleExtOUJumpSwingEngine__SWIG_0((ext::shared_ptr< ExtOUWithJumpsProcess > const &)*arg1,(ext::shared_ptr< YieldTermStructure > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > *smartresult = result ? new ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FdSimpleExtOUJumpSwingEngine(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FdSimpleExtOUJumpSwingEngine", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_5(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ext__shared_ptrT_ExtOUWithJumpsProcess_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ext__shared_ptrT_YieldTermStructure_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_FdmSchemeDesc, SWIG_POINTER_NO_NULL | 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_FdSimpleExtOUJumpSwingEngine__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FdSimpleExtOUJumpSwingEngine'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FdSimpleExtOUJumpSwingEngine::FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size,Size,std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &,FdmSchemeDesc const &)\n"
    "    FdSimpleExtOUJumpSwingEngine::FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size,Size,std::vector< std::pair< Time,Real >,std::allocator< std::pair< Time,Real > > > const &)\n"
    "    FdSimpleExtOUJumpSwingEngine::FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size,Size)\n"
    "    FdSimpleExtOUJumpSwingEngine::FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size,Size)\n"
    "    FdSimpleExtOUJumpSwingEngine::FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const &,ext::shared_ptr< YieldTermStructure > const &,Size)\n"
    "    FdSimpleExtOUJumpSwingEngine::FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const &,ext::shared_ptr< YieldTermStructure > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FdSimpleExtOUJumpSwingEngine(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FdSimpleExtOUJumpSwingEngine *arg1 = (FdSimpleExtOUJumpSwingEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > tempshared1 ;
  ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdSimpleExtOUJumpSwingEngine" "', argument " "1"" of type '" "FdSimpleExtOUJumpSwingEngine *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > * >(argp1);
      arg1 = const_cast< FdSimpleExtOUJumpSwingEngine * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  FdSimpleExtOUJumpSwingEngine > * >(argp1);
      arg1 = const_cast< FdSimpleExtOUJumpSwingEngine * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FdSimpleExtOUJumpSwingEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *FdSimpleExtOUJumpSwingEngine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_enableTracing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "enableTracing", 0, 0, 0)) SWIG_fail;
  {
    try {
      enableTracing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disableTracing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "disableTracing", 0, 0, 0)) SWIG_fail;
  {
    try {
      disableTracing();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstantEstimator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Size arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ConstantEstimator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantEstimator" "', argument " "1"" of type '" "Size""'");
  } 
  arg1 = static_cast< Size >(val1);
  {
    try {
      result = (ConstantEstimator *)new ConstantEstimator(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ConstantEstimator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstantEstimator_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantEstimator *arg1 = (ConstantEstimator *) 0 ;
  TimeSeries< Volatility > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ConstantEstimator_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstantEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantEstimator_calculate" "', argument " "1"" of type '" "ConstantEstimator *""'"); 
  }
  arg1 = reinterpret_cast< ConstantEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantEstimator_calculate" "', argument " "2"" of type '" "TimeSeries< Volatility > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantEstimator_calculate" "', argument " "2"" of type '" "TimeSeries< Volatility > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< Volatility > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< Volatility > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConstantEstimator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ConstantEstimator *arg1 = (ConstantEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstantEstimator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantEstimator" "', argument " "1"" of type '" "ConstantEstimator *""'"); 
  }
  arg1 = reinterpret_cast< ConstantEstimator * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstantEstimator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ConstantEstimator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstantEstimator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ParkinsonSigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  ParkinsonSigma *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParkinsonSigma" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (ParkinsonSigma *)new ParkinsonSigma(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ParkinsonSigma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParkinsonSigma_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ParkinsonSigma *arg1 = (ParkinsonSigma *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "ParkinsonSigma_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ParkinsonSigma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParkinsonSigma_calculate" "', argument " "1"" of type '" "ParkinsonSigma *""'"); 
  }
  arg1 = reinterpret_cast< ParkinsonSigma * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParkinsonSigma_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParkinsonSigma_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ParkinsonSigma(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  ParkinsonSigma *arg1 = (ParkinsonSigma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ParkinsonSigma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParkinsonSigma" "', argument " "1"" of type '" "ParkinsonSigma *""'"); 
  }
  arg1 = reinterpret_cast< ParkinsonSigma * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ParkinsonSigma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ParkinsonSigma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ParkinsonSigma_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GarmanKlassSigma1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  GarmanKlassSigma1 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GarmanKlassSigma1", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GarmanKlassSigma1" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GarmanKlassSigma1" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GarmanKlassSigma1 *)new GarmanKlassSigma1(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GarmanKlassSigma1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GarmanKlassSigma1_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma1 *arg1 = (GarmanKlassSigma1 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "GarmanKlassSigma1_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GarmanKlassSigma1_calculate" "', argument " "1"" of type '" "GarmanKlassSigma1 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma1 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GarmanKlassSigma1_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GarmanKlassSigma1_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GarmanKlassSigma1(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma1 *arg1 = (GarmanKlassSigma1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma1, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GarmanKlassSigma1" "', argument " "1"" of type '" "GarmanKlassSigma1 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma1 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GarmanKlassSigma1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GarmanKlassSigma1, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GarmanKlassSigma1_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GarmanKlassSigma3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  GarmanKlassSigma3 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GarmanKlassSigma3", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GarmanKlassSigma3" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GarmanKlassSigma3" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GarmanKlassSigma3 *)new GarmanKlassSigma3(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GarmanKlassSigma3, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GarmanKlassSigma3_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma3 *arg1 = (GarmanKlassSigma3 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "GarmanKlassSigma3_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GarmanKlassSigma3_calculate" "', argument " "1"" of type '" "GarmanKlassSigma3 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma3 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GarmanKlassSigma3_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GarmanKlassSigma3_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GarmanKlassSigma3(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma3 *arg1 = (GarmanKlassSigma3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma3, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GarmanKlassSigma3" "', argument " "1"" of type '" "GarmanKlassSigma3 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma3 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GarmanKlassSigma3_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GarmanKlassSigma3, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GarmanKlassSigma3_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GarmanKlassSigma4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GarmanKlassSigma4 *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GarmanKlassSigma4" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (GarmanKlassSigma4 *)new GarmanKlassSigma4(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GarmanKlassSigma4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GarmanKlassSigma4_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma4 *arg1 = (GarmanKlassSigma4 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "GarmanKlassSigma4_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GarmanKlassSigma4_calculate" "', argument " "1"" of type '" "GarmanKlassSigma4 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma4 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GarmanKlassSigma4_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GarmanKlassSigma4_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GarmanKlassSigma4(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma4 *arg1 = (GarmanKlassSigma4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GarmanKlassSigma4" "', argument " "1"" of type '" "GarmanKlassSigma4 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma4 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GarmanKlassSigma4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GarmanKlassSigma4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GarmanKlassSigma4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GarmanKlassSigma5(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  GarmanKlassSigma5 *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GarmanKlassSigma5" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  {
    try {
      result = (GarmanKlassSigma5 *)new GarmanKlassSigma5(arg1);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GarmanKlassSigma5, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GarmanKlassSigma5_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma5 *arg1 = (GarmanKlassSigma5 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "GarmanKlassSigma5_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma5, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GarmanKlassSigma5_calculate" "', argument " "1"" of type '" "GarmanKlassSigma5 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma5 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GarmanKlassSigma5_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GarmanKlassSigma5_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GarmanKlassSigma5(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma5 *arg1 = (GarmanKlassSigma5 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma5, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GarmanKlassSigma5" "', argument " "1"" of type '" "GarmanKlassSigma5 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma5 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GarmanKlassSigma5_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GarmanKlassSigma5, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GarmanKlassSigma5_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_GarmanKlassSigma6(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  Real arg1 ;
  Real arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  GarmanKlassSigma6 *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_GarmanKlassSigma6", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GarmanKlassSigma6" "', argument " "1"" of type '" "Real""'");
  } 
  arg1 = static_cast< Real >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GarmanKlassSigma6" "', argument " "2"" of type '" "Real""'");
  } 
  arg2 = static_cast< Real >(val2);
  {
    try {
      result = (GarmanKlassSigma6 *)new GarmanKlassSigma6(arg1,arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GarmanKlassSigma6, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GarmanKlassSigma6_calculate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma6 *arg1 = (GarmanKlassSigma6 *) 0 ;
  TimeSeries< IntervalPrice > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  TimeSeries< Volatility > result;
  
  if (!SWIG_Python_UnpackTuple(args, "GarmanKlassSigma6_calculate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma6, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GarmanKlassSigma6_calculate" "', argument " "1"" of type '" "GarmanKlassSigma6 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma6 * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_TimeSeriesT_IntervalPrice_std__mapT_Date_IntervalPrice_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_IntervalPrice_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GarmanKlassSigma6_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GarmanKlassSigma6_calculate" "', argument " "2"" of type '" "TimeSeries< IntervalPrice > const &""'"); 
  }
  arg2 = reinterpret_cast< TimeSeries< IntervalPrice > * >(argp2);
  {
    try {
      result = (arg1)->calculate((TimeSeries< IntervalPrice > const &)*arg2);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_NewPointerObj((new TimeSeries< Volatility >(result)), SWIGTYPE_p_TimeSeriesT_double_std__mapT_Date_double_std__lessT_Date_t_std__allocatorT_std__pairT_Date_const_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GarmanKlassSigma6(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  GarmanKlassSigma6 *arg1 = (GarmanKlassSigma6 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_GarmanKlassSigma6, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GarmanKlassSigma6" "', argument " "1"" of type '" "GarmanKlassSigma6 *""'"); 
  }
  arg1 = reinterpret_cast< GarmanKlassSigma6 * >(argp1);
  {
    try {
      delete arg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GarmanKlassSigma6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_GarmanKlassSigma6, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *GarmanKlassSigma6_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Linear *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Linear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ZeroCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "5"" of type '" "Linear const &""'"); 
  }
  arg5 = reinterpret_cast< Linear * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Linear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< Linear > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< Linear > *)new InterpolatedZeroCurve< Linear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Linear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Linear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_ZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_ZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Linear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< Linear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Linear const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< Linear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Linear const &,Compounding)\n"
    "    InterpolatedZeroCurve< Linear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Linear const &)\n"
    "    InterpolatedZeroCurve< Linear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< Linear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< Linear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< Linear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< Linear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< Linear > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< Linear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< Linear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Linear > *arg1 = (InterpolatedZeroCurve< Linear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Linear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< Linear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Linear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Linear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Linear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogLinearZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogLinearZeroCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  arg5 = reinterpret_cast< LogLinear * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogLinearZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LogLinearZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogLinearZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogLinearZeroCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  arg5 = reinterpret_cast< LogLinear * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogLinearZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogLinearZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  LogLinear *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_LogLinear,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogLinearZeroCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "5"" of type '" "LogLinear const &""'"); 
  }
  arg5 = reinterpret_cast< LogLinear * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(LogLinear const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogLinearZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogLinearZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< LogLinear > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogLinearZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< LogLinear > *)new InterpolatedZeroCurve< LogLinear >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogLinearZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LogLinearZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LogLinearZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LogLinearZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LogLinearZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_LogLinearZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_LogLinear, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LogLinearZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LogLinearZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< LogLinear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,LogLinear const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< LogLinear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,LogLinear const &,Compounding)\n"
    "    InterpolatedZeroCurve< LogLinear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,LogLinear const &)\n"
    "    InterpolatedZeroCurve< LogLinear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< LogLinear >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogLinearZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< LogLinear > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< LogLinear > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< LogLinear > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< LogLinear > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogLinearZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogLinearZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< LogLinear > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< LogLinear > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LogLinearZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< LogLinear > *arg1 = (InterpolatedZeroCurve< LogLinear > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogLinearZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< LogLinear > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<LogLinear> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< LogLinear > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogLinearZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogLinearZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_CubicZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicZeroCurve" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CubicZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Cubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicZeroCurve" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Cubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Cubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Cubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CubicZeroCurve" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "5"" of type '" "Cubic const &""'"); 
  }
  arg5 = reinterpret_cast< Cubic * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Cubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< Cubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< Cubic > *)new InterpolatedZeroCurve< Cubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Cubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CubicZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CubicZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_CubicZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_CubicZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CubicZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_CubicZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Cubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CubicZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CubicZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< Cubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Cubic const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< Cubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Cubic const &,Compounding)\n"
    "    InterpolatedZeroCurve< Cubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Cubic const &)\n"
    "    InterpolatedZeroCurve< Cubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< Cubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CubicZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< Cubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< Cubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< Cubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< Cubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< Cubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< Cubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< Cubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< Cubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CubicZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< Cubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< Cubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CubicZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Cubic > *arg1 = (InterpolatedZeroCurve< Cubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CubicZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< Cubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Cubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Cubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CubicZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CubicZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_NaturalCubicZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NaturalCubicZeroCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_NaturalCubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_NaturalCubicZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NaturalCubicZeroCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_NaturalCubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  SplineCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_SplineCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NaturalCubicZeroCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "5"" of type '" "SplineCubic const &""'"); 
  }
  arg5 = reinterpret_cast< SplineCubic * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(SplineCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< SplineCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NaturalCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< SplineCubic > *)new InterpolatedZeroCurve< SplineCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NaturalCubicZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_NaturalCubicZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NaturalCubicZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_NaturalCubicZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_NaturalCubicZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_NaturalCubicZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_SplineCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_NaturalCubicZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NaturalCubicZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< SplineCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,SplineCubic const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< SplineCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,SplineCubic const &,Compounding)\n"
    "    InterpolatedZeroCurve< SplineCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,SplineCubic const &)\n"
    "    InterpolatedZeroCurve< SplineCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< SplineCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NaturalCubicZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< SplineCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< SplineCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< SplineCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< SplineCubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaturalCubicZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaturalCubicZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< SplineCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< SplineCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NaturalCubicZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< SplineCubic > *arg1 = (InterpolatedZeroCurve< SplineCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NaturalCubicZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< SplineCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<SplineCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< SplineCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NaturalCubicZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *NaturalCubicZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_LogCubicZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultLogCubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DefaultLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogCubicZeroCurve" "', argument " "5"" of type '" "DefaultLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "5"" of type '" "DefaultLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< DefaultLogCubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogCubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LogCubicZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(DefaultLogCubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogCubicZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultLogCubic *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DefaultLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogCubicZeroCurve" "', argument " "5"" of type '" "DefaultLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "5"" of type '" "DefaultLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< DefaultLogCubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LogCubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(DefaultLogCubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogCubicZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  DefaultLogCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_DefaultLogCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_LogCubicZeroCurve" "', argument " "5"" of type '" "DefaultLogCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "5"" of type '" "DefaultLogCubic const &""'"); 
  }
  arg5 = reinterpret_cast< DefaultLogCubic * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(DefaultLogCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogCubicZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogCubicZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< DefaultLogCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< DefaultLogCubic > *)new InterpolatedZeroCurve< DefaultLogCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LogCubicZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_LogCubicZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LogCubicZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LogCubicZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DefaultLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_LogCubicZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DefaultLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_LogCubicZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_DefaultLogCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_LogCubicZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LogCubicZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< DefaultLogCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,DefaultLogCubic const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< DefaultLogCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,DefaultLogCubic const &,Compounding)\n"
    "    InterpolatedZeroCurve< DefaultLogCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,DefaultLogCubic const &)\n"
    "    InterpolatedZeroCurve< DefaultLogCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< DefaultLogCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogCubicZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< DefaultLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< DefaultLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< DefaultLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< DefaultLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogCubicZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogCubicZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< DefaultLogCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< DefaultLogCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LogCubicZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< DefaultLogCubic > *arg1 = (InterpolatedZeroCurve< DefaultLogCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogCubicZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< DefaultLogCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<DefaultLogCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< DefaultLogCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogCubicZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *LogCubicZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_MonotonicCubicZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicCubic const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicCubic const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  MonotonicCubic *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_MonotonicCubic,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "5"" of type '" "MonotonicCubic const &""'"); 
  }
  arg5 = reinterpret_cast< MonotonicCubic * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(MonotonicCubic const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< MonotonicCubic > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MonotonicCubicZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< MonotonicCubic > *)new InterpolatedZeroCurve< MonotonicCubic >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MonotonicCubicZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MonotonicCubicZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MonotonicCubicZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MonotonicCubicZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_MonotonicCubicZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_MonotonicCubicZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_MonotonicCubic, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_MonotonicCubicZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MonotonicCubicZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< MonotonicCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,MonotonicCubic const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< MonotonicCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,MonotonicCubic const &,Compounding)\n"
    "    InterpolatedZeroCurve< MonotonicCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,MonotonicCubic const &)\n"
    "    InterpolatedZeroCurve< MonotonicCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< MonotonicCubic >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< MonotonicCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< MonotonicCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< MonotonicCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< MonotonicCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MonotonicCubicZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MonotonicCubicZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< MonotonicCubic > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< MonotonicCubic > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MonotonicCubicZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< MonotonicCubic > *arg1 = (InterpolatedZeroCurve< MonotonicCubic > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MonotonicCubicZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< MonotonicCubic > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<MonotonicCubic> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< MonotonicCubic > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MonotonicCubicZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MonotonicCubicZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_KrugerZeroCurve__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Kruger *arg5 = 0 ;
  Compounding arg6 ;
  Frequency arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_KrugerZeroCurve" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  arg5 = reinterpret_cast< Kruger * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_KrugerZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_KrugerZeroCurve" "', argument " "7"" of type '" "Frequency""'");
  } 
  arg7 = static_cast< Frequency >(val7);
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Kruger const &)*arg5,arg6,arg7);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerZeroCurve__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Kruger *arg5 = 0 ;
  Compounding arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_KrugerZeroCurve" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  arg5 = reinterpret_cast< Kruger * >(argp5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_KrugerZeroCurve" "', argument " "6"" of type '" "Compounding""'");
  } 
  arg6 = static_cast< Compounding >(val6);
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Kruger const &)*arg5,arg6);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerZeroCurve__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  Kruger *arg5 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Kruger,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_KrugerZeroCurve" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "5"" of type '" "Kruger const &""'"); 
  }
  arg5 = reinterpret_cast< Kruger * >(argp5);
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4,(Kruger const &)*arg5);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerZeroCurve__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  Calendar *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Calendar,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "4"" of type '" "Calendar const &""'"); 
  }
  arg4 = reinterpret_cast< Calendar * >(argp4);
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3,(Calendar const &)*arg4);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerZeroCurve__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< Date,std::allocator< Date > > *arg1 = 0 ;
  std::vector< Rate,std::allocator< Rate > > *arg2 = 0 ;
  DayCounter *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  InterpolatedZeroCurve< Kruger > *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< Date,std::allocator< Date > > *ptr = (std::vector< Date,std::allocator< Date > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "1"" of type '" "std::vector< Date,std::allocator< Date > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "2"" of type '" "std::vector< Rate,std::allocator< Rate > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_DayCounter,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KrugerZeroCurve" "', argument " "3"" of type '" "DayCounter const &""'"); 
  }
  arg3 = reinterpret_cast< DayCounter * >(argp3);
  {
    try {
      result = (InterpolatedZeroCurve< Kruger > *)new InterpolatedZeroCurve< Kruger >((std::vector< Date,std::allocator< Date > > const &)*arg1,(std::vector< Rate,std::allocator< Rate > > const &)*arg2,(DayCounter const &)*arg3);
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  {
    ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > *smartresult = result ? new ext::shared_ptr<  InterpolatedZeroCurve<Kruger> >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_KrugerZeroCurve(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_KrugerZeroCurve", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_KrugerZeroCurve__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_KrugerZeroCurve__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_KrugerZeroCurve__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_KrugerZeroCurve__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< Date,std::allocator< Date > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_DayCounter, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Calendar, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Kruger, SWIG_POINTER_NO_NULL | 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_KrugerZeroCurve__SWIG_0(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_KrugerZeroCurve'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    InterpolatedZeroCurve< Kruger >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Kruger const &,Compounding,Frequency)\n"
    "    InterpolatedZeroCurve< Kruger >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Kruger const &,Compounding)\n"
    "    InterpolatedZeroCurve< Kruger >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &,Kruger const &)\n"
    "    InterpolatedZeroCurve< Kruger >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &,Calendar const &)\n"
    "    InterpolatedZeroCurve< Kruger >::InterpolatedZeroCurve(std::vector< Date,std::allocator< Date > > const &,std::vector< Rate,std::allocator< Rate > > const &,DayCounter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_KrugerZeroCurve_times(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Time,std::allocator< Time > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerZeroCurve_times" "', argument " "1"" of type '" "InterpolatedZeroCurve< Kruger > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Time,std::allocator< Time > > *) &((InterpolatedZeroCurve< Kruger > const *)arg1)->times();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerZeroCurve_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Real,std::allocator< Real > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerZeroCurve_data" "', argument " "1"" of type '" "InterpolatedZeroCurve< Kruger > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Real,std::allocator< Real > > *) &((InterpolatedZeroCurve< Kruger > const *)arg1)->data();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerZeroCurve_dates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Date,std::allocator< Date > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerZeroCurve_dates" "', argument " "1"" of type '" "InterpolatedZeroCurve< Kruger > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Date,std::allocator< Date > > *) &((InterpolatedZeroCurve< Kruger > const *)arg1)->dates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< Date,std::allocator< Date > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerZeroCurve_zeroRates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< Rate,std::allocator< Rate > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerZeroCurve_zeroRates" "', argument " "1"" of type '" "InterpolatedZeroCurve< Kruger > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< Rate,std::allocator< Rate > > *) &((InterpolatedZeroCurve< Kruger > const *)arg1)->zeroRates();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_KrugerZeroCurve_nodes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< Date,Rate >,std::allocator< std::pair< Date,Rate > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KrugerZeroCurve_nodes" "', argument " "1"" of type '" "InterpolatedZeroCurve< Kruger > const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr< const InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((InterpolatedZeroCurve< Kruger > const *)arg1)->nodes();
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< Date,double >,std::allocator< std::pair< Date,double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_KrugerZeroCurve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  InterpolatedZeroCurve< Kruger > *arg1 = (InterpolatedZeroCurve< Kruger > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > > tempshared1 ;
  ext::shared_ptr< InterpolatedZeroCurve< Kruger > > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KrugerZeroCurve" "', argument " "1"" of type '" "InterpolatedZeroCurve< Kruger > *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > * >(argp1);
      delete reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< ext::shared_ptr<  InterpolatedZeroCurve<Kruger> > * >(argp1);
      arg1 = const_cast< InterpolatedZeroCurve< Kruger > * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    } catch (std::out_of_range& e) {
      SWIG_exception(SWIG_IndexError,const_cast<char*>(e.what()));
    } catch (std::exception& e) {
      SWIG_exception(SWIG_RuntimeError,const_cast<char*>(e.what()));
    } catch (...) {
      SWIG_exception(SWIG_UnknownError,"unknown error");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *KrugerZeroCurve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *KrugerZeroCurve_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

static PyMethodDef SwigMethods[] = {
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "Period_length", _wrap_Period_length, METH_O, "Period_length(Period self) -> Integer"},
	 { "Period_units", _wrap_Period_units, METH_O, "Period_units(Period self) -> TimeUnit"},
	 { "Period_frequency", _wrap_Period_frequency, METH_O, "Period_frequency(Period self) -> Frequency"},
	 { "Period_normalized", _wrap_Period_normalized, METH_O, "Period_normalized(Period self) -> Period"},
	 { "new_Period", _wrap_new_Period, METH_VARARGS, "\n"
		"Period()\n"
		"Period(Integer n, TimeUnit units)\n"
		"Period(Frequency arg1)\n"
		"new_Period(std::string const & str) -> Period\n"
		""},
	 { "Period___str__", _wrap_Period___str__, METH_O, "Period___str__(Period self) -> std::string"},
	 { "Period___repr__", _wrap_Period___repr__, METH_O, "Period___repr__(Period self) -> std::string"},
	 { "Period___neg__", _wrap_Period___neg__, METH_O, "Period___neg__(Period self) -> Period"},
	 { "Period___add__", _wrap_Period___add__, METH_VARARGS, "Period___add__(Period self, Period p) -> Period"},
	 { "Period___sub__", _wrap_Period___sub__, METH_VARARGS, "Period___sub__(Period self, Period p) -> Period"},
	 { "Period___mul__", _wrap_Period___mul__, METH_VARARGS, "Period___mul__(Period self, Integer n) -> Period"},
	 { "Period___rmul__", _wrap_Period___rmul__, METH_VARARGS, "Period___rmul__(Period self, Integer n) -> Period"},
	 { "Period___lt__", _wrap_Period___lt__, METH_VARARGS, "Period___lt__(Period self, Period other) -> bool"},
	 { "Period___gt__", _wrap_Period___gt__, METH_VARARGS, "Period___gt__(Period self, Period other) -> bool"},
	 { "Period___le__", _wrap_Period___le__, METH_VARARGS, "Period___le__(Period self, Period other) -> bool"},
	 { "Period___ge__", _wrap_Period___ge__, METH_VARARGS, "Period___ge__(Period self, Period other) -> bool"},
	 { "Period___eq__", _wrap_Period___eq__, METH_VARARGS, "Period___eq__(Period self, Period other) -> bool"},
	 { "Period___cmp__", _wrap_Period___cmp__, METH_VARARGS, "Period___cmp__(Period self, Period other) -> int"},
	 { "delete_Period", _wrap_delete_Period, METH_O, "delete_Period(Period self)"},
	 { "Period_swigregister", Period_swigregister, METH_O, NULL},
	 { "Period_swiginit", Period_swiginit, METH_VARARGS, NULL},
	 { "PeriodVector_iterator", _wrap_PeriodVector_iterator, METH_O, "PeriodVector_iterator(PeriodVector self) -> SwigPyIterator"},
	 { "PeriodVector___nonzero__", _wrap_PeriodVector___nonzero__, METH_O, "PeriodVector___nonzero__(PeriodVector self) -> bool"},
	 { "PeriodVector___bool__", _wrap_PeriodVector___bool__, METH_O, "PeriodVector___bool__(PeriodVector self) -> bool"},
	 { "PeriodVector___len__", _wrap_PeriodVector___len__, METH_O, "PeriodVector___len__(PeriodVector self) -> std::vector< Period >::size_type"},
	 { "PeriodVector___getslice__", _wrap_PeriodVector___getslice__, METH_VARARGS, "PeriodVector___getslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j) -> PeriodVector"},
	 { "PeriodVector___setslice__", _wrap_PeriodVector___setslice__, METH_VARARGS, "\n"
		"PeriodVector___setslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j)\n"
		"PeriodVector___setslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j, PeriodVector v)\n"
		""},
	 { "PeriodVector___delslice__", _wrap_PeriodVector___delslice__, METH_VARARGS, "PeriodVector___delslice__(PeriodVector self, std::vector< Period >::difference_type i, std::vector< Period >::difference_type j)"},
	 { "PeriodVector___delitem__", _wrap_PeriodVector___delitem__, METH_VARARGS, "\n"
		"PeriodVector___delitem__(PeriodVector self, std::vector< Period >::difference_type i)\n"
		"PeriodVector___delitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "PeriodVector___getitem__", _wrap_PeriodVector___getitem__, METH_VARARGS, "\n"
		"PeriodVector___getitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice) -> PeriodVector\n"
		"PeriodVector___getitem__(PeriodVector self, std::vector< Period >::difference_type i) -> Period\n"
		""},
	 { "PeriodVector___setitem__", _wrap_PeriodVector___setitem__, METH_VARARGS, "\n"
		"PeriodVector___setitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice, PeriodVector v)\n"
		"PeriodVector___setitem__(PeriodVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"PeriodVector___setitem__(PeriodVector self, std::vector< Period >::difference_type i, Period x)\n"
		""},
	 { "PeriodVector_pop", _wrap_PeriodVector_pop, METH_O, "PeriodVector_pop(PeriodVector self) -> Period"},
	 { "PeriodVector_append", _wrap_PeriodVector_append, METH_VARARGS, "PeriodVector_append(PeriodVector self, Period x)"},
	 { "PeriodVector_empty", _wrap_PeriodVector_empty, METH_O, "PeriodVector_empty(PeriodVector self) -> bool"},
	 { "PeriodVector_size", _wrap_PeriodVector_size, METH_O, "PeriodVector_size(PeriodVector self) -> std::vector< Period >::size_type"},
	 { "PeriodVector_swap", _wrap_PeriodVector_swap, METH_VARARGS, "PeriodVector_swap(PeriodVector self, PeriodVector v)"},
	 { "PeriodVector_begin", _wrap_PeriodVector_begin, METH_O, "PeriodVector_begin(PeriodVector self) -> std::vector< Period >::iterator"},
	 { "PeriodVector_end", _wrap_PeriodVector_end, METH_O, "PeriodVector_end(PeriodVector self) -> std::vector< Period >::iterator"},
	 { "PeriodVector_rbegin", _wrap_PeriodVector_rbegin, METH_O, "PeriodVector_rbegin(PeriodVector self) -> std::vector< Period >::reverse_iterator"},
	 { "PeriodVector_rend", _wrap_PeriodVector_rend, METH_O, "PeriodVector_rend(PeriodVector self) -> std::vector< Period >::reverse_iterator"},
	 { "PeriodVector_clear", _wrap_PeriodVector_clear, METH_O, "PeriodVector_clear(PeriodVector self)"},
	 { "PeriodVector_get_allocator", _wrap_PeriodVector_get_allocator, METH_O, "PeriodVector_get_allocator(PeriodVector self) -> std::vector< Period >::allocator_type"},
	 { "PeriodVector_pop_back", _wrap_PeriodVector_pop_back, METH_O, "PeriodVector_pop_back(PeriodVector self)"},
	 { "PeriodVector_erase", _wrap_PeriodVector_erase, METH_VARARGS, "\n"
		"PeriodVector_erase(PeriodVector self, std::vector< Period >::iterator pos) -> std::vector< Period >::iterator\n"
		"PeriodVector_erase(PeriodVector self, std::vector< Period >::iterator first, std::vector< Period >::iterator last) -> std::vector< Period >::iterator\n"
		""},
	 { "new_PeriodVector", _wrap_new_PeriodVector, METH_VARARGS, "\n"
		"PeriodVector()\n"
		"PeriodVector(PeriodVector other)\n"
		"PeriodVector(std::vector< Period >::size_type size)\n"
		"new_PeriodVector(std::vector< Period >::size_type size, Period value) -> PeriodVector\n"
		""},
	 { "PeriodVector_push_back", _wrap_PeriodVector_push_back, METH_VARARGS, "PeriodVector_push_back(PeriodVector self, Period x)"},
	 { "PeriodVector_front", _wrap_PeriodVector_front, METH_O, "PeriodVector_front(PeriodVector self) -> Period"},
	 { "PeriodVector_back", _wrap_PeriodVector_back, METH_O, "PeriodVector_back(PeriodVector self) -> Period"},
	 { "PeriodVector_assign", _wrap_PeriodVector_assign, METH_VARARGS, "PeriodVector_assign(PeriodVector self, std::vector< Period >::size_type n, Period x)"},
	 { "PeriodVector_resize", _wrap_PeriodVector_resize, METH_VARARGS, "\n"
		"PeriodVector_resize(PeriodVector self, std::vector< Period >::size_type new_size)\n"
		"PeriodVector_resize(PeriodVector self, std::vector< Period >::size_type new_size, Period x)\n"
		""},
	 { "PeriodVector_insert", _wrap_PeriodVector_insert, METH_VARARGS, "\n"
		"PeriodVector_insert(PeriodVector self, std::vector< Period >::iterator pos, Period x) -> std::vector< Period >::iterator\n"
		"PeriodVector_insert(PeriodVector self, std::vector< Period >::iterator pos, std::vector< Period >::size_type n, Period x)\n"
		""},
	 { "PeriodVector_reserve", _wrap_PeriodVector_reserve, METH_VARARGS, "PeriodVector_reserve(PeriodVector self, std::vector< Period >::size_type n)"},
	 { "PeriodVector_capacity", _wrap_PeriodVector_capacity, METH_O, "PeriodVector_capacity(PeriodVector self) -> std::vector< Period >::size_type"},
	 { "delete_PeriodVector", _wrap_delete_PeriodVector, METH_O, "delete_PeriodVector(PeriodVector self)"},
	 { "PeriodVector_swigregister", PeriodVector_swigregister, METH_O, NULL},
	 { "PeriodVector_swiginit", PeriodVector_swiginit, METH_VARARGS, NULL},
	 { "Date_weekday", _wrap_Date_weekday, METH_O, "Date_weekday(Date self) -> Weekday"},
	 { "Date_dayOfMonth", _wrap_Date_dayOfMonth, METH_O, "Date_dayOfMonth(Date self) -> Day"},
	 { "Date_dayOfYear", _wrap_Date_dayOfYear, METH_O, "Date_dayOfYear(Date self) -> Day"},
	 { "Date_month", _wrap_Date_month, METH_O, "Date_month(Date self) -> Month"},
	 { "Date_year", _wrap_Date_year, METH_O, "Date_year(Date self) -> Year"},
	 { "Date_hours", _wrap_Date_hours, METH_O, "Date_hours(Date self) -> Hour"},
	 { "Date_minutes", _wrap_Date_minutes, METH_O, "Date_minutes(Date self) -> Minute"},
	 { "Date_seconds", _wrap_Date_seconds, METH_O, "Date_seconds(Date self) -> Second"},
	 { "Date_milliseconds", _wrap_Date_milliseconds, METH_O, "Date_milliseconds(Date self) -> Millisecond"},
	 { "Date_microseconds", _wrap_Date_microseconds, METH_O, "Date_microseconds(Date self) -> Microsecond"},
	 { "Date_fractionOfDay", _wrap_Date_fractionOfDay, METH_O, "Date_fractionOfDay(Date self) -> Time"},
	 { "Date_fractionOfSecond", _wrap_Date_fractionOfSecond, METH_O, "Date_fractionOfSecond(Date self) -> Time"},
	 { "Date_serialNumber", _wrap_Date_serialNumber, METH_O, "Date_serialNumber(Date self) -> BigInteger"},
	 { "Date_isLeap", _wrap_Date_isLeap, METH_O, "Date_isLeap(Year y) -> bool"},
	 { "Date_minDate", _wrap_Date_minDate, METH_NOARGS, "Date_minDate() -> Date"},
	 { "Date_maxDate", _wrap_Date_maxDate, METH_NOARGS, "Date_maxDate() -> Date"},
	 { "Date_todaysDate", _wrap_Date_todaysDate, METH_NOARGS, "Date_todaysDate() -> Date"},
	 { "Date_localDateTime", _wrap_Date_localDateTime, METH_NOARGS, "Date_localDateTime() -> Date"},
	 { "Date_universalDateTime", _wrap_Date_universalDateTime, METH_NOARGS, "Date_universalDateTime() -> Date"},
	 { "Date_endOfMonth", _wrap_Date_endOfMonth, METH_O, "Date_endOfMonth(Date arg1) -> Date"},
	 { "Date_isEndOfMonth", _wrap_Date_isEndOfMonth, METH_O, "Date_isEndOfMonth(Date arg1) -> bool"},
	 { "Date_nextWeekday", _wrap_Date_nextWeekday, METH_VARARGS, "Date_nextWeekday(Date arg1, Weekday arg2) -> Date"},
	 { "Date_nthWeekday", _wrap_Date_nthWeekday, METH_VARARGS, "Date_nthWeekday(Size n, Weekday arg2, Month m, Year y) -> Date"},
	 { "Date___add__", _wrap_Date___add__, METH_VARARGS, "\n"
		"Date___add__(Date self, BigInteger days) -> Date\n"
		"Date___add__(Date self, Period arg2) -> Date\n"
		""},
	 { "new_Date", _wrap_new_Date, METH_VARARGS, "\n"
		"Date()\n"
		"Date(Day d, Month m, Year y)\n"
		"Date(Day d, Month m, Year y, Hour hours, Minute minutes, Second seconds, Millisecond millisec=0, Microsecond microsec=0)\n"
		"Date(BigInteger serialNumber)\n"
		"new_Date(std::string const & str, std::string fmt) -> Date\n"
		""},
	 { "Date_weekdayNumber", _wrap_Date_weekdayNumber, METH_O, "Date_weekdayNumber(Date self) -> Integer"},
	 { "Date___str__", _wrap_Date___str__, METH_O, "Date___str__(Date self) -> std::string"},
	 { "Date___repr__", _wrap_Date___repr__, METH_O, "Date___repr__(Date self) -> std::string"},
	 { "Date_ISO", _wrap_Date_ISO, METH_O, "Date_ISO(Date self) -> std::string"},
	 { "Date___sub__", _wrap_Date___sub__, METH_VARARGS, "\n"
		"Date___sub__(Date self, BigInteger days) -> Date\n"
		"Date___sub__(Date self, Period arg2) -> Date\n"
		"Date___sub__(Date self, Date other) -> BigInteger\n"
		""},
	 { "Date___eq__", _wrap_Date___eq__, METH_VARARGS, "Date___eq__(Date self, Date other) -> bool"},
	 { "Date___cmp__", _wrap_Date___cmp__, METH_VARARGS, "Date___cmp__(Date self, Date other) -> int"},
	 { "Date___nonzero__", _wrap_Date___nonzero__, METH_O, "Date___nonzero__(Date self) -> bool"},
	 { "Date___bool__", _wrap_Date___bool__, METH_O, "Date___bool__(Date self) -> bool"},
	 { "Date___hash__", _wrap_Date___hash__, METH_O, "Date___hash__(Date self) -> int"},
	 { "Date___lt__", _wrap_Date___lt__, METH_VARARGS, "Date___lt__(Date self, Date other) -> bool"},
	 { "Date___gt__", _wrap_Date___gt__, METH_VARARGS, "Date___gt__(Date self, Date other) -> bool"},
	 { "Date___le__", _wrap_Date___le__, METH_VARARGS, "Date___le__(Date self, Date other) -> bool"},
	 { "Date___ge__", _wrap_Date___ge__, METH_VARARGS, "Date___ge__(Date self, Date other) -> bool"},
	 { "Date___ne__", _wrap_Date___ne__, METH_VARARGS, "Date___ne__(Date self, Date other) -> bool"},
	 { "delete_Date", _wrap_delete_Date, METH_O, "delete_Date(Date self)"},
	 { "Date_swigregister", Date_swigregister, METH_O, NULL},
	 { "Date_swiginit", Date_swiginit, METH_VARARGS, NULL},
	 { "DateParser_parseFormatted", _wrap_DateParser_parseFormatted, METH_VARARGS, "DateParser_parseFormatted(std::string const & str, std::string const & fmt) -> Date"},
	 { "DateParser_parseISO", _wrap_DateParser_parseISO, METH_O, "DateParser_parseISO(std::string const & str) -> Date"},
	 { "DateParser_parse", _wrap_DateParser_parse, METH_VARARGS, "DateParser_parse(std::string const & str, std::string fmt) -> Date"},
	 { "new_DateParser", _wrap_new_DateParser, METH_NOARGS, "new_DateParser() -> DateParser"},
	 { "delete_DateParser", _wrap_delete_DateParser, METH_O, "delete_DateParser(DateParser self)"},
	 { "DateParser_swigregister", DateParser_swigregister, METH_O, NULL},
	 { "DateParser_swiginit", DateParser_swiginit, METH_VARARGS, NULL},
	 { "PeriodParser_parse", _wrap_PeriodParser_parse, METH_O, "PeriodParser_parse(std::string const & str) -> Period"},
	 { "new_PeriodParser", _wrap_new_PeriodParser, METH_NOARGS, "new_PeriodParser() -> PeriodParser"},
	 { "delete_PeriodParser", _wrap_delete_PeriodParser, METH_O, "delete_PeriodParser(PeriodParser self)"},
	 { "PeriodParser_swigregister", PeriodParser_swigregister, METH_O, NULL},
	 { "PeriodParser_swiginit", PeriodParser_swiginit, METH_VARARGS, NULL},
	 { "DateVector_iterator", _wrap_DateVector_iterator, METH_O, "DateVector_iterator(DateVector self) -> SwigPyIterator"},
	 { "DateVector___nonzero__", _wrap_DateVector___nonzero__, METH_O, "DateVector___nonzero__(DateVector self) -> bool"},
	 { "DateVector___bool__", _wrap_DateVector___bool__, METH_O, "DateVector___bool__(DateVector self) -> bool"},
	 { "DateVector___len__", _wrap_DateVector___len__, METH_O, "DateVector___len__(DateVector self) -> std::vector< Date >::size_type"},
	 { "DateVector___getslice__", _wrap_DateVector___getslice__, METH_VARARGS, "DateVector___getslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j) -> DateVector"},
	 { "DateVector___setslice__", _wrap_DateVector___setslice__, METH_VARARGS, "\n"
		"DateVector___setslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j)\n"
		"DateVector___setslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j, DateVector v)\n"
		""},
	 { "DateVector___delslice__", _wrap_DateVector___delslice__, METH_VARARGS, "DateVector___delslice__(DateVector self, std::vector< Date >::difference_type i, std::vector< Date >::difference_type j)"},
	 { "DateVector___delitem__", _wrap_DateVector___delitem__, METH_VARARGS, "\n"
		"DateVector___delitem__(DateVector self, std::vector< Date >::difference_type i)\n"
		"DateVector___delitem__(DateVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "DateVector___getitem__", _wrap_DateVector___getitem__, METH_VARARGS, "\n"
		"DateVector___getitem__(DateVector self, SWIGPY_SLICEOBJECT * slice) -> DateVector\n"
		"DateVector___getitem__(DateVector self, std::vector< Date >::difference_type i) -> Date\n"
		""},
	 { "DateVector___setitem__", _wrap_DateVector___setitem__, METH_VARARGS, "\n"
		"DateVector___setitem__(DateVector self, SWIGPY_SLICEOBJECT * slice, DateVector v)\n"
		"DateVector___setitem__(DateVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"DateVector___setitem__(DateVector self, std::vector< Date >::difference_type i, Date x)\n"
		""},
	 { "DateVector_pop", _wrap_DateVector_pop, METH_O, "DateVector_pop(DateVector self) -> Date"},
	 { "DateVector_append", _wrap_DateVector_append, METH_VARARGS, "DateVector_append(DateVector self, Date x)"},
	 { "DateVector_empty", _wrap_DateVector_empty, METH_O, "DateVector_empty(DateVector self) -> bool"},
	 { "DateVector_size", _wrap_DateVector_size, METH_O, "DateVector_size(DateVector self) -> std::vector< Date >::size_type"},
	 { "DateVector_swap", _wrap_DateVector_swap, METH_VARARGS, "DateVector_swap(DateVector self, DateVector v)"},
	 { "DateVector_begin", _wrap_DateVector_begin, METH_O, "DateVector_begin(DateVector self) -> std::vector< Date >::iterator"},
	 { "DateVector_end", _wrap_DateVector_end, METH_O, "DateVector_end(DateVector self) -> std::vector< Date >::iterator"},
	 { "DateVector_rbegin", _wrap_DateVector_rbegin, METH_O, "DateVector_rbegin(DateVector self) -> std::vector< Date >::reverse_iterator"},
	 { "DateVector_rend", _wrap_DateVector_rend, METH_O, "DateVector_rend(DateVector self) -> std::vector< Date >::reverse_iterator"},
	 { "DateVector_clear", _wrap_DateVector_clear, METH_O, "DateVector_clear(DateVector self)"},
	 { "DateVector_get_allocator", _wrap_DateVector_get_allocator, METH_O, "DateVector_get_allocator(DateVector self) -> std::vector< Date >::allocator_type"},
	 { "DateVector_pop_back", _wrap_DateVector_pop_back, METH_O, "DateVector_pop_back(DateVector self)"},
	 { "DateVector_erase", _wrap_DateVector_erase, METH_VARARGS, "\n"
		"DateVector_erase(DateVector self, std::vector< Date >::iterator pos) -> std::vector< Date >::iterator\n"
		"DateVector_erase(DateVector self, std::vector< Date >::iterator first, std::vector< Date >::iterator last) -> std::vector< Date >::iterator\n"
		""},
	 { "new_DateVector", _wrap_new_DateVector, METH_VARARGS, "\n"
		"DateVector()\n"
		"DateVector(DateVector other)\n"
		"DateVector(std::vector< Date >::size_type size)\n"
		"new_DateVector(std::vector< Date >::size_type size, Date value) -> DateVector\n"
		""},
	 { "DateVector_push_back", _wrap_DateVector_push_back, METH_VARARGS, "DateVector_push_back(DateVector self, Date x)"},
	 { "DateVector_front", _wrap_DateVector_front, METH_O, "DateVector_front(DateVector self) -> Date"},
	 { "DateVector_back", _wrap_DateVector_back, METH_O, "DateVector_back(DateVector self) -> Date"},
	 { "DateVector_assign", _wrap_DateVector_assign, METH_VARARGS, "DateVector_assign(DateVector self, std::vector< Date >::size_type n, Date x)"},
	 { "DateVector_resize", _wrap_DateVector_resize, METH_VARARGS, "\n"
		"DateVector_resize(DateVector self, std::vector< Date >::size_type new_size)\n"
		"DateVector_resize(DateVector self, std::vector< Date >::size_type new_size, Date x)\n"
		""},
	 { "DateVector_insert", _wrap_DateVector_insert, METH_VARARGS, "\n"
		"DateVector_insert(DateVector self, std::vector< Date >::iterator pos, Date x) -> std::vector< Date >::iterator\n"
		"DateVector_insert(DateVector self, std::vector< Date >::iterator pos, std::vector< Date >::size_type n, Date x)\n"
		""},
	 { "DateVector_reserve", _wrap_DateVector_reserve, METH_VARARGS, "DateVector_reserve(DateVector self, std::vector< Date >::size_type n)"},
	 { "DateVector_capacity", _wrap_DateVector_capacity, METH_O, "DateVector_capacity(DateVector self) -> std::vector< Date >::size_type"},
	 { "delete_DateVector", _wrap_delete_DateVector, METH_O, "delete_DateVector(DateVector self)"},
	 { "DateVector_swigregister", DateVector_swigregister, METH_O, NULL},
	 { "DateVector_swiginit", DateVector_swiginit, METH_VARARGS, NULL},
	 { "daysBetween", _wrap_daysBetween, METH_VARARGS, "daysBetween(Date arg1, Date arg2) -> Time"},
	 { "IMM_isIMMdate", _wrap_IMM_isIMMdate, METH_VARARGS, "IMM_isIMMdate(Date d, bool mainCycle=True) -> bool"},
	 { "IMM_isIMMcode", _wrap_IMM_isIMMcode, METH_VARARGS, "IMM_isIMMcode(std::string const & code, bool mainCycle=True) -> bool"},
	 { "IMM_code", _wrap_IMM_code, METH_O, "IMM_code(Date immDate) -> std::string"},
	 { "IMM_date", _wrap_IMM_date, METH_VARARGS, "IMM_date(std::string const & immCode, Date referenceDate=Date()) -> Date"},
	 { "IMM_nextDate", _wrap_IMM_nextDate, METH_VARARGS, "\n"
		"IMM_nextDate(Date d=Date(), bool mainCycle=True) -> Date\n"
		"IMM_nextDate(std::string const & immCode, bool mainCycle=True, Date referenceDate=Date()) -> Date\n"
		""},
	 { "IMM_nextCode", _wrap_IMM_nextCode, METH_VARARGS, "\n"
		"IMM_nextCode(Date d=Date(), bool mainCycle=True) -> std::string\n"
		"IMM_nextCode(std::string const & immCode, bool mainCycle=True, Date referenceDate=Date()) -> std::string\n"
		""},
	 { "new_IMM", _wrap_new_IMM, METH_NOARGS, "new_IMM() -> IMM"},
	 { "delete_IMM", _wrap_delete_IMM, METH_O, "delete_IMM(IMM self)"},
	 { "IMM_swigregister", IMM_swigregister, METH_O, NULL},
	 { "IMM_swiginit", IMM_swiginit, METH_VARARGS, NULL},
	 { "ASX_isASXdate", _wrap_ASX_isASXdate, METH_VARARGS, "ASX_isASXdate(Date d, bool mainCycle=True) -> bool"},
	 { "ASX_isASXcode", _wrap_ASX_isASXcode, METH_VARARGS, "ASX_isASXcode(std::string const & code, bool mainCycle=True) -> bool"},
	 { "ASX_code", _wrap_ASX_code, METH_O, "ASX_code(Date asxDate) -> std::string"},
	 { "ASX_date", _wrap_ASX_date, METH_VARARGS, "ASX_date(std::string const & asxCode, Date referenceDate=Date()) -> Date"},
	 { "ASX_nextDate", _wrap_ASX_nextDate, METH_VARARGS, "\n"
		"ASX_nextDate(Date d=Date(), bool mainCycle=True) -> Date\n"
		"ASX_nextDate(std::string const & asxCode, bool mainCycle=True, Date referenceDate=Date()) -> Date\n"
		""},
	 { "ASX_nextCode", _wrap_ASX_nextCode, METH_VARARGS, "\n"
		"ASX_nextCode(Date d=Date(), bool mainCycle=True) -> std::string\n"
		"ASX_nextCode(std::string const & asxCode, bool mainCycle=True, Date referenceDate=Date()) -> std::string\n"
		""},
	 { "new_ASX", _wrap_new_ASX, METH_NOARGS, "new_ASX() -> ASX"},
	 { "delete_ASX", _wrap_delete_ASX, METH_O, "delete_ASX(ASX self)"},
	 { "ASX_swigregister", ASX_swigregister, METH_O, NULL},
	 { "ASX_swiginit", ASX_swiginit, METH_VARARGS, NULL},
	 { "IntVector_iterator", _wrap_IntVector_iterator, METH_O, "IntVector_iterator(IntVector self) -> SwigPyIterator"},
	 { "IntVector___nonzero__", _wrap_IntVector___nonzero__, METH_O, "IntVector___nonzero__(IntVector self) -> bool"},
	 { "IntVector___bool__", _wrap_IntVector___bool__, METH_O, "IntVector___bool__(IntVector self) -> bool"},
	 { "IntVector___len__", _wrap_IntVector___len__, METH_O, "IntVector___len__(IntVector self) -> std::vector< int >::size_type"},
	 { "IntVector___getslice__", _wrap_IntVector___getslice__, METH_VARARGS, "IntVector___getslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> IntVector"},
	 { "IntVector___setslice__", _wrap_IntVector___setslice__, METH_VARARGS, "\n"
		"IntVector___setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
		"IntVector___setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, IntVector v)\n"
		""},
	 { "IntVector___delslice__", _wrap_IntVector___delslice__, METH_VARARGS, "IntVector___delslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
	 { "IntVector___delitem__", _wrap_IntVector___delitem__, METH_VARARGS, "\n"
		"IntVector___delitem__(IntVector self, std::vector< int >::difference_type i)\n"
		"IntVector___delitem__(IntVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "IntVector___getitem__", _wrap_IntVector___getitem__, METH_VARARGS, "\n"
		"IntVector___getitem__(IntVector self, SWIGPY_SLICEOBJECT * slice) -> IntVector\n"
		"IntVector___getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
		""},
	 { "IntVector___setitem__", _wrap_IntVector___setitem__, METH_VARARGS, "\n"
		"IntVector___setitem__(IntVector self, SWIGPY_SLICEOBJECT * slice, IntVector v)\n"
		"IntVector___setitem__(IntVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"IntVector___setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
		""},
	 { "IntVector_pop", _wrap_IntVector_pop, METH_O, "IntVector_pop(IntVector self) -> std::vector< int >::value_type"},
	 { "IntVector_append", _wrap_IntVector_append, METH_VARARGS, "IntVector_append(IntVector self, std::vector< int >::value_type const & x)"},
	 { "IntVector_empty", _wrap_IntVector_empty, METH_O, "IntVector_empty(IntVector self) -> bool"},
	 { "IntVector_size", _wrap_IntVector_size, METH_O, "IntVector_size(IntVector self) -> std::vector< int >::size_type"},
	 { "IntVector_swap", _wrap_IntVector_swap, METH_VARARGS, "IntVector_swap(IntVector self, IntVector v)"},
	 { "IntVector_begin", _wrap_IntVector_begin, METH_O, "IntVector_begin(IntVector self) -> std::vector< int >::iterator"},
	 { "IntVector_end", _wrap_IntVector_end, METH_O, "IntVector_end(IntVector self) -> std::vector< int >::iterator"},
	 { "IntVector_rbegin", _wrap_IntVector_rbegin, METH_O, "IntVector_rbegin(IntVector self) -> std::vector< int >::reverse_iterator"},
	 { "IntVector_rend", _wrap_IntVector_rend, METH_O, "IntVector_rend(IntVector self) -> std::vector< int >::reverse_iterator"},
	 { "IntVector_clear", _wrap_IntVector_clear, METH_O, "IntVector_clear(IntVector self)"},
	 { "IntVector_get_allocator", _wrap_IntVector_get_allocator, METH_O, "IntVector_get_allocator(IntVector self) -> std::vector< int >::allocator_type"},
	 { "IntVector_pop_back", _wrap_IntVector_pop_back, METH_O, "IntVector_pop_back(IntVector self)"},
	 { "IntVector_erase", _wrap_IntVector_erase, METH_VARARGS, "\n"
		"IntVector_erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator\n"
		"IntVector_erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator\n"
		""},
	 { "new_IntVector", _wrap_new_IntVector, METH_VARARGS, "\n"
		"IntVector()\n"
		"IntVector(IntVector other)\n"
		"IntVector(std::vector< int >::size_type size)\n"
		"new_IntVector(std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector\n"
		""},
	 { "IntVector_push_back", _wrap_IntVector_push_back, METH_VARARGS, "IntVector_push_back(IntVector self, std::vector< int >::value_type const & x)"},
	 { "IntVector_front", _wrap_IntVector_front, METH_O, "IntVector_front(IntVector self) -> std::vector< int >::value_type const &"},
	 { "IntVector_back", _wrap_IntVector_back, METH_O, "IntVector_back(IntVector self) -> std::vector< int >::value_type const &"},
	 { "IntVector_assign", _wrap_IntVector_assign, METH_VARARGS, "IntVector_assign(IntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"},
	 { "IntVector_resize", _wrap_IntVector_resize, METH_VARARGS, "\n"
		"IntVector_resize(IntVector self, std::vector< int >::size_type new_size)\n"
		"IntVector_resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)\n"
		""},
	 { "IntVector_insert", _wrap_IntVector_insert, METH_VARARGS, "\n"
		"IntVector_insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator\n"
		"IntVector_insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)\n"
		""},
	 { "IntVector_reserve", _wrap_IntVector_reserve, METH_VARARGS, "IntVector_reserve(IntVector self, std::vector< int >::size_type n)"},
	 { "IntVector_capacity", _wrap_IntVector_capacity, METH_O, "IntVector_capacity(IntVector self) -> std::vector< int >::size_type"},
	 { "delete_IntVector", _wrap_delete_IntVector, METH_O, "delete_IntVector(IntVector self)"},
	 { "IntVector_swigregister", IntVector_swigregister, METH_O, NULL},
	 { "IntVector_swiginit", IntVector_swiginit, METH_VARARGS, NULL},
	 { "UnsignedIntVector_iterator", _wrap_UnsignedIntVector_iterator, METH_O, "UnsignedIntVector_iterator(UnsignedIntVector self) -> SwigPyIterator"},
	 { "UnsignedIntVector___nonzero__", _wrap_UnsignedIntVector___nonzero__, METH_O, "UnsignedIntVector___nonzero__(UnsignedIntVector self) -> bool"},
	 { "UnsignedIntVector___bool__", _wrap_UnsignedIntVector___bool__, METH_O, "UnsignedIntVector___bool__(UnsignedIntVector self) -> bool"},
	 { "UnsignedIntVector___len__", _wrap_UnsignedIntVector___len__, METH_O, "UnsignedIntVector___len__(UnsignedIntVector self) -> std::vector< unsigned int >::size_type"},
	 { "UnsignedIntVector___getslice__", _wrap_UnsignedIntVector___getslice__, METH_VARARGS, "UnsignedIntVector___getslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> UnsignedIntVector"},
	 { "UnsignedIntVector___setslice__", _wrap_UnsignedIntVector___setslice__, METH_VARARGS, "\n"
		"UnsignedIntVector___setslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)\n"
		"UnsignedIntVector___setslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, UnsignedIntVector v)\n"
		""},
	 { "UnsignedIntVector___delslice__", _wrap_UnsignedIntVector___delslice__, METH_VARARGS, "UnsignedIntVector___delslice__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"},
	 { "UnsignedIntVector___delitem__", _wrap_UnsignedIntVector___delitem__, METH_VARARGS, "\n"
		"UnsignedIntVector___delitem__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i)\n"
		"UnsignedIntVector___delitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "UnsignedIntVector___getitem__", _wrap_UnsignedIntVector___getitem__, METH_VARARGS, "\n"
		"UnsignedIntVector___getitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice) -> UnsignedIntVector\n"
		"UnsignedIntVector___getitem__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &\n"
		""},
	 { "UnsignedIntVector___setitem__", _wrap_UnsignedIntVector___setitem__, METH_VARARGS, "\n"
		"UnsignedIntVector___setitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice, UnsignedIntVector v)\n"
		"UnsignedIntVector___setitem__(UnsignedIntVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"UnsignedIntVector___setitem__(UnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)\n"
		""},
	 { "UnsignedIntVector_pop", _wrap_UnsignedIntVector_pop, METH_O, "UnsignedIntVector_pop(UnsignedIntVector self) -> std::vector< unsigned int >::value_type"},
	 { "UnsignedIntVector_append", _wrap_UnsignedIntVector_append, METH_VARARGS, "UnsignedIntVector_append(UnsignedIntVector self, std::vector< unsigned int >::value_type const & x)"},
	 { "UnsignedIntVector_empty", _wrap_UnsignedIntVector_empty, METH_O, "UnsignedIntVector_empty(UnsignedIntVector self) -> bool"},
	 { "UnsignedIntVector_size", _wrap_UnsignedIntVector_size, METH_O, "UnsignedIntVector_size(UnsignedIntVector self) -> std::vector< unsigned int >::size_type"},
	 { "UnsignedIntVector_swap", _wrap_UnsignedIntVector_swap, METH_VARARGS, "UnsignedIntVector_swap(UnsignedIntVector self, UnsignedIntVector v)"},
	 { "UnsignedIntVector_begin", _wrap_UnsignedIntVector_begin, METH_O, "UnsignedIntVector_begin(UnsignedIntVector self) -> std::vector< unsigned int >::iterator"},
	 { "UnsignedIntVector_end", _wrap_UnsignedIntVector_end, METH_O, "UnsignedIntVector_end(UnsignedIntVector self) -> std::vector< unsigned int >::iterator"},
	 { "UnsignedIntVector_rbegin", _wrap_UnsignedIntVector_rbegin, METH_O, "UnsignedIntVector_rbegin(UnsignedIntVector self) -> std::vector< unsigned int >::reverse_iterator"},
	 { "UnsignedIntVector_rend", _wrap_UnsignedIntVector_rend, METH_O, "UnsignedIntVector_rend(UnsignedIntVector self) -> std::vector< unsigned int >::reverse_iterator"},
	 { "UnsignedIntVector_clear", _wrap_UnsignedIntVector_clear, METH_O, "UnsignedIntVector_clear(UnsignedIntVector self)"},
	 { "UnsignedIntVector_get_allocator", _wrap_UnsignedIntVector_get_allocator, METH_O, "UnsignedIntVector_get_allocator(UnsignedIntVector self) -> std::vector< unsigned int >::allocator_type"},
	 { "UnsignedIntVector_pop_back", _wrap_UnsignedIntVector_pop_back, METH_O, "UnsignedIntVector_pop_back(UnsignedIntVector self)"},
	 { "UnsignedIntVector_erase", _wrap_UnsignedIntVector_erase, METH_VARARGS, "\n"
		"UnsignedIntVector_erase(UnsignedIntVector self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator\n"
		"UnsignedIntVector_erase(UnsignedIntVector self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator\n"
		""},
	 { "new_UnsignedIntVector", _wrap_new_UnsignedIntVector, METH_VARARGS, "\n"
		"UnsignedIntVector()\n"
		"UnsignedIntVector(UnsignedIntVector other)\n"
		"UnsignedIntVector(std::vector< unsigned int >::size_type size)\n"
		"new_UnsignedIntVector(std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> UnsignedIntVector\n"
		""},
	 { "UnsignedIntVector_push_back", _wrap_UnsignedIntVector_push_back, METH_VARARGS, "UnsignedIntVector_push_back(UnsignedIntVector self, std::vector< unsigned int >::value_type const & x)"},
	 { "UnsignedIntVector_front", _wrap_UnsignedIntVector_front, METH_O, "UnsignedIntVector_front(UnsignedIntVector self) -> std::vector< unsigned int >::value_type const &"},
	 { "UnsignedIntVector_back", _wrap_UnsignedIntVector_back, METH_O, "UnsignedIntVector_back(UnsignedIntVector self) -> std::vector< unsigned int >::value_type const &"},
	 { "UnsignedIntVector_assign", _wrap_UnsignedIntVector_assign, METH_VARARGS, "UnsignedIntVector_assign(UnsignedIntVector self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"},
	 { "UnsignedIntVector_resize", _wrap_UnsignedIntVector_resize, METH_VARARGS, "\n"
		"UnsignedIntVector_resize(UnsignedIntVector self, std::vector< unsigned int >::size_type new_size)\n"
		"UnsignedIntVector_resize(UnsignedIntVector self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)\n"
		""},
	 { "UnsignedIntVector_insert", _wrap_UnsignedIntVector_insert, METH_VARARGS, "\n"
		"UnsignedIntVector_insert(UnsignedIntVector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator\n"
		"UnsignedIntVector_insert(UnsignedIntVector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)\n"
		""},
	 { "UnsignedIntVector_reserve", _wrap_UnsignedIntVector_reserve, METH_VARARGS, "UnsignedIntVector_reserve(UnsignedIntVector self, std::vector< unsigned int >::size_type n)"},
	 { "UnsignedIntVector_capacity", _wrap_UnsignedIntVector_capacity, METH_O, "UnsignedIntVector_capacity(UnsignedIntVector self) -> std::vector< unsigned int >::size_type"},
	 { "delete_UnsignedIntVector", _wrap_delete_UnsignedIntVector, METH_O, "delete_UnsignedIntVector(UnsignedIntVector self)"},
	 { "UnsignedIntVector_swigregister", UnsignedIntVector_swigregister, METH_O, NULL},
	 { "UnsignedIntVector_swiginit", UnsignedIntVector_swiginit, METH_VARARGS, NULL},
	 { "DoubleVector_iterator", _wrap_DoubleVector_iterator, METH_O, "DoubleVector_iterator(DoubleVector self) -> SwigPyIterator"},
	 { "DoubleVector___nonzero__", _wrap_DoubleVector___nonzero__, METH_O, "DoubleVector___nonzero__(DoubleVector self) -> bool"},
	 { "DoubleVector___bool__", _wrap_DoubleVector___bool__, METH_O, "DoubleVector___bool__(DoubleVector self) -> bool"},
	 { "DoubleVector___len__", _wrap_DoubleVector___len__, METH_O, "DoubleVector___len__(DoubleVector self) -> std::vector< double >::size_type"},
	 { "DoubleVector___getslice__", _wrap_DoubleVector___getslice__, METH_VARARGS, "DoubleVector___getslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> DoubleVector"},
	 { "DoubleVector___setslice__", _wrap_DoubleVector___setslice__, METH_VARARGS, "\n"
		"DoubleVector___setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
		"DoubleVector___setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, DoubleVector v)\n"
		""},
	 { "DoubleVector___delslice__", _wrap_DoubleVector___delslice__, METH_VARARGS, "DoubleVector___delslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
	 { "DoubleVector___delitem__", _wrap_DoubleVector___delitem__, METH_VARARGS, "\n"
		"DoubleVector___delitem__(DoubleVector self, std::vector< double >::difference_type i)\n"
		"DoubleVector___delitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "DoubleVector___getitem__", _wrap_DoubleVector___getitem__, METH_VARARGS, "\n"
		"DoubleVector___getitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice) -> DoubleVector\n"
		"DoubleVector___getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
		""},
	 { "DoubleVector___setitem__", _wrap_DoubleVector___setitem__, METH_VARARGS, "\n"
		"DoubleVector___setitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice, DoubleVector v)\n"
		"DoubleVector___setitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"DoubleVector___setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
		""},
	 { "DoubleVector_pop", _wrap_DoubleVector_pop, METH_O, "DoubleVector_pop(DoubleVector self) -> std::vector< double >::value_type"},
	 { "DoubleVector_append", _wrap_DoubleVector_append, METH_VARARGS, "DoubleVector_append(DoubleVector self, std::vector< double >::value_type const & x)"},
	 { "DoubleVector_empty", _wrap_DoubleVector_empty, METH_O, "DoubleVector_empty(DoubleVector self) -> bool"},
	 { "DoubleVector_size", _wrap_DoubleVector_size, METH_O, "DoubleVector_size(DoubleVector self) -> std::vector< double >::size_type"},
	 { "DoubleVector_swap", _wrap_DoubleVector_swap, METH_VARARGS, "DoubleVector_swap(DoubleVector self, DoubleVector v)"},
	 { "DoubleVector_begin", _wrap_DoubleVector_begin, METH_O, "DoubleVector_begin(DoubleVector self) -> std::vector< double >::iterator"},
	 { "DoubleVector_end", _wrap_DoubleVector_end, METH_O, "DoubleVector_end(DoubleVector self) -> std::vector< double >::iterator"},
	 { "DoubleVector_rbegin", _wrap_DoubleVector_rbegin, METH_O, "DoubleVector_rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"},
	 { "DoubleVector_rend", _wrap_DoubleVector_rend, METH_O, "DoubleVector_rend(DoubleVector self) -> std::vector< double >::reverse_iterator"},
	 { "DoubleVector_clear", _wrap_DoubleVector_clear, METH_O, "DoubleVector_clear(DoubleVector self)"},
	 { "DoubleVector_get_allocator", _wrap_DoubleVector_get_allocator, METH_O, "DoubleVector_get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"},
	 { "DoubleVector_pop_back", _wrap_DoubleVector_pop_back, METH_O, "DoubleVector_pop_back(DoubleVector self)"},
	 { "DoubleVector_erase", _wrap_DoubleVector_erase, METH_VARARGS, "\n"
		"DoubleVector_erase(DoubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator\n"
		"DoubleVector_erase(DoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator\n"
		""},
	 { "new_DoubleVector", _wrap_new_DoubleVector, METH_VARARGS, "\n"
		"DoubleVector()\n"
		"DoubleVector(DoubleVector other)\n"
		"DoubleVector(std::vector< double >::size_type size)\n"
		"new_DoubleVector(std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector\n"
		""},
	 { "DoubleVector_push_back", _wrap_DoubleVector_push_back, METH_VARARGS, "DoubleVector_push_back(DoubleVector self, std::vector< double >::value_type const & x)"},
	 { "DoubleVector_front", _wrap_DoubleVector_front, METH_O, "DoubleVector_front(DoubleVector self) -> std::vector< double >::value_type const &"},
	 { "DoubleVector_back", _wrap_DoubleVector_back, METH_O, "DoubleVector_back(DoubleVector self) -> std::vector< double >::value_type const &"},
	 { "DoubleVector_assign", _wrap_DoubleVector_assign, METH_VARARGS, "DoubleVector_assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"},
	 { "DoubleVector_resize", _wrap_DoubleVector_resize, METH_VARARGS, "\n"
		"DoubleVector_resize(DoubleVector self, std::vector< double >::size_type new_size)\n"
		"DoubleVector_resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)\n"
		""},
	 { "DoubleVector_insert", _wrap_DoubleVector_insert, METH_VARARGS, "\n"
		"DoubleVector_insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator\n"
		"DoubleVector_insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)\n"
		""},
	 { "DoubleVector_reserve", _wrap_DoubleVector_reserve, METH_VARARGS, "DoubleVector_reserve(DoubleVector self, std::vector< double >::size_type n)"},
	 { "DoubleVector_capacity", _wrap_DoubleVector_capacity, METH_O, "DoubleVector_capacity(DoubleVector self) -> std::vector< double >::size_type"},
	 { "delete_DoubleVector", _wrap_delete_DoubleVector, METH_O, "delete_DoubleVector(DoubleVector self)"},
	 { "DoubleVector_swigregister", DoubleVector_swigregister, METH_O, NULL},
	 { "DoubleVector_swiginit", DoubleVector_swiginit, METH_VARARGS, NULL},
	 { "StrVector_iterator", _wrap_StrVector_iterator, METH_O, "StrVector_iterator(StrVector self) -> SwigPyIterator"},
	 { "StrVector___nonzero__", _wrap_StrVector___nonzero__, METH_O, "StrVector___nonzero__(StrVector self) -> bool"},
	 { "StrVector___bool__", _wrap_StrVector___bool__, METH_O, "StrVector___bool__(StrVector self) -> bool"},
	 { "StrVector___len__", _wrap_StrVector___len__, METH_O, "StrVector___len__(StrVector self) -> std::vector< std::string >::size_type"},
	 { "StrVector___getslice__", _wrap_StrVector___getslice__, METH_VARARGS, "StrVector___getslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StrVector"},
	 { "StrVector___setslice__", _wrap_StrVector___setslice__, METH_VARARGS, "\n"
		"StrVector___setslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
		"StrVector___setslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StrVector v)\n"
		""},
	 { "StrVector___delslice__", _wrap_StrVector___delslice__, METH_VARARGS, "StrVector___delslice__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
	 { "StrVector___delitem__", _wrap_StrVector___delitem__, METH_VARARGS, "\n"
		"StrVector___delitem__(StrVector self, std::vector< std::string >::difference_type i)\n"
		"StrVector___delitem__(StrVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "StrVector___getitem__", _wrap_StrVector___getitem__, METH_VARARGS, "\n"
		"StrVector___getitem__(StrVector self, SWIGPY_SLICEOBJECT * slice) -> StrVector\n"
		"StrVector___getitem__(StrVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
		""},
	 { "StrVector___setitem__", _wrap_StrVector___setitem__, METH_VARARGS, "\n"
		"StrVector___setitem__(StrVector self, SWIGPY_SLICEOBJECT * slice, StrVector v)\n"
		"StrVector___setitem__(StrVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"StrVector___setitem__(StrVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
		""},
	 { "StrVector_pop", _wrap_StrVector_pop, METH_O, "StrVector_pop(StrVector self) -> std::vector< std::string >::value_type"},
	 { "StrVector_append", _wrap_StrVector_append, METH_VARARGS, "StrVector_append(StrVector self, std::vector< std::string >::value_type const & x)"},
	 { "StrVector_empty", _wrap_StrVector_empty, METH_O, "StrVector_empty(StrVector self) -> bool"},
	 { "StrVector_size", _wrap_StrVector_size, METH_O, "StrVector_size(StrVector self) -> std::vector< std::string >::size_type"},
	 { "StrVector_swap", _wrap_StrVector_swap, METH_VARARGS, "StrVector_swap(StrVector self, StrVector v)"},
	 { "StrVector_begin", _wrap_StrVector_begin, METH_O, "StrVector_begin(StrVector self) -> std::vector< std::string >::iterator"},
	 { "StrVector_end", _wrap_StrVector_end, METH_O, "StrVector_end(StrVector self) -> std::vector< std::string >::iterator"},
	 { "StrVector_rbegin", _wrap_StrVector_rbegin, METH_O, "StrVector_rbegin(StrVector self) -> std::vector< std::string >::reverse_iterator"},
	 { "StrVector_rend", _wrap_StrVector_rend, METH_O, "StrVector_rend(StrVector self) -> std::vector< std::string >::reverse_iterator"},
	 { "StrVector_clear", _wrap_StrVector_clear, METH_O, "StrVector_clear(StrVector self)"},
	 { "StrVector_get_allocator", _wrap_StrVector_get_allocator, METH_O, "StrVector_get_allocator(StrVector self) -> std::vector< std::string >::allocator_type"},
	 { "StrVector_pop_back", _wrap_StrVector_pop_back, METH_O, "StrVector_pop_back(StrVector self)"},
	 { "StrVector_erase", _wrap_StrVector_erase, METH_VARARGS, "\n"
		"StrVector_erase(StrVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator\n"
		"StrVector_erase(StrVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator\n"
		""},
	 { "new_StrVector", _wrap_new_StrVector, METH_VARARGS, "\n"
		"StrVector()\n"
		"StrVector(StrVector other)\n"
		"StrVector(std::vector< std::string >::size_type size)\n"
		"new_StrVector(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StrVector\n"
		""},
	 { "StrVector_push_back", _wrap_StrVector_push_back, METH_VARARGS, "StrVector_push_back(StrVector self, std::vector< std::string >::value_type const & x)"},
	 { "StrVector_front", _wrap_StrVector_front, METH_O, "StrVector_front(StrVector self) -> std::vector< std::string >::value_type const &"},
	 { "StrVector_back", _wrap_StrVector_back, METH_O, "StrVector_back(StrVector self) -> std::vector< std::string >::value_type const &"},
	 { "StrVector_assign", _wrap_StrVector_assign, METH_VARARGS, "StrVector_assign(StrVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"},
	 { "StrVector_resize", _wrap_StrVector_resize, METH_VARARGS, "\n"
		"StrVector_resize(StrVector self, std::vector< std::string >::size_type new_size)\n"
		"StrVector_resize(StrVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)\n"
		""},
	 { "StrVector_insert", _wrap_StrVector_insert, METH_VARARGS, "\n"
		"StrVector_insert(StrVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator\n"
		"StrVector_insert(StrVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)\n"
		""},
	 { "StrVector_reserve", _wrap_StrVector_reserve, METH_VARARGS, "StrVector_reserve(StrVector self, std::vector< std::string >::size_type n)"},
	 { "StrVector_capacity", _wrap_StrVector_capacity, METH_O, "StrVector_capacity(StrVector self) -> std::vector< std::string >::size_type"},
	 { "delete_StrVector", _wrap_delete_StrVector, METH_O, "delete_StrVector(StrVector self)"},
	 { "StrVector_swigregister", StrVector_swigregister, METH_O, NULL},
	 { "StrVector_swiginit", StrVector_swiginit, METH_VARARGS, NULL},
	 { "BoolVector_iterator", _wrap_BoolVector_iterator, METH_O, "BoolVector_iterator(BoolVector self) -> SwigPyIterator"},
	 { "BoolVector___nonzero__", _wrap_BoolVector___nonzero__, METH_O, "BoolVector___nonzero__(BoolVector self) -> bool"},
	 { "BoolVector___bool__", _wrap_BoolVector___bool__, METH_O, "BoolVector___bool__(BoolVector self) -> bool"},
	 { "BoolVector___len__", _wrap_BoolVector___len__, METH_O, "BoolVector___len__(BoolVector self) -> std::vector< bool >::size_type"},
	 { "BoolVector___getslice__", _wrap_BoolVector___getslice__, METH_VARARGS, "BoolVector___getslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j) -> BoolVector"},
	 { "BoolVector___setslice__", _wrap_BoolVector___setslice__, METH_VARARGS, "\n"
		"BoolVector___setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)\n"
		"BoolVector___setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j, BoolVector v)\n"
		""},
	 { "BoolVector___delslice__", _wrap_BoolVector___delslice__, METH_VARARGS, "BoolVector___delslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)"},
	 { "BoolVector___delitem__", _wrap_BoolVector___delitem__, METH_VARARGS, "\n"
		"BoolVector___delitem__(BoolVector self, std::vector< bool >::difference_type i)\n"
		"BoolVector___delitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "BoolVector___getitem__", _wrap_BoolVector___getitem__, METH_VARARGS, "\n"
		"BoolVector___getitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice) -> BoolVector\n"
		"BoolVector___getitem__(BoolVector self, std::vector< bool >::difference_type i) -> std::vector< bool >::value_type\n"
		""},
	 { "BoolVector___setitem__", _wrap_BoolVector___setitem__, METH_VARARGS, "\n"
		"BoolVector___setitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice, BoolVector v)\n"
		"BoolVector___setitem__(BoolVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"BoolVector___setitem__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::value_type x)\n"
		""},
	 { "BoolVector_pop", _wrap_BoolVector_pop, METH_O, "BoolVector_pop(BoolVector self) -> std::vector< bool >::value_type"},
	 { "BoolVector_append", _wrap_BoolVector_append, METH_VARARGS, "BoolVector_append(BoolVector self, std::vector< bool >::value_type x)"},
	 { "BoolVector_empty", _wrap_BoolVector_empty, METH_O, "BoolVector_empty(BoolVector self) -> bool"},
	 { "BoolVector_size", _wrap_BoolVector_size, METH_O, "BoolVector_size(BoolVector self) -> std::vector< bool >::size_type"},
	 { "BoolVector_swap", _wrap_BoolVector_swap, METH_VARARGS, "BoolVector_swap(BoolVector self, BoolVector v)"},
	 { "BoolVector_begin", _wrap_BoolVector_begin, METH_O, "BoolVector_begin(BoolVector self) -> std::vector< bool >::iterator"},
	 { "BoolVector_end", _wrap_BoolVector_end, METH_O, "BoolVector_end(BoolVector self) -> std::vector< bool >::iterator"},
	 { "BoolVector_rbegin", _wrap_BoolVector_rbegin, METH_O, "BoolVector_rbegin(BoolVector self) -> std::vector< bool >::reverse_iterator"},
	 { "BoolVector_rend", _wrap_BoolVector_rend, METH_O, "BoolVector_rend(BoolVector self) -> std::vector< bool >::reverse_iterator"},
	 { "BoolVector_clear", _wrap_BoolVector_clear, METH_O, "BoolVector_clear(BoolVector self)"},
	 { "BoolVector_get_allocator", _wrap_BoolVector_get_allocator, METH_O, "BoolVector_get_allocator(BoolVector self) -> std::vector< bool >::allocator_type"},
	 { "BoolVector_pop_back", _wrap_BoolVector_pop_back, METH_O, "BoolVector_pop_back(BoolVector self)"},
	 { "BoolVector_erase", _wrap_BoolVector_erase, METH_VARARGS, "\n"
		"BoolVector_erase(BoolVector self, std::vector< bool >::iterator pos) -> std::vector< bool >::iterator\n"
		"BoolVector_erase(BoolVector self, std::vector< bool >::iterator first, std::vector< bool >::iterator last) -> std::vector< bool >::iterator\n"
		""},
	 { "new_BoolVector", _wrap_new_BoolVector, METH_VARARGS, "\n"
		"BoolVector()\n"
		"BoolVector(BoolVector other)\n"
		"BoolVector(std::vector< bool >::size_type size)\n"
		"new_BoolVector(std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> BoolVector\n"
		""},
	 { "BoolVector_push_back", _wrap_BoolVector_push_back, METH_VARARGS, "BoolVector_push_back(BoolVector self, std::vector< bool >::value_type x)"},
	 { "BoolVector_front", _wrap_BoolVector_front, METH_O, "BoolVector_front(BoolVector self) -> std::vector< bool >::value_type"},
	 { "BoolVector_back", _wrap_BoolVector_back, METH_O, "BoolVector_back(BoolVector self) -> std::vector< bool >::value_type"},
	 { "BoolVector_assign", _wrap_BoolVector_assign, METH_VARARGS, "BoolVector_assign(BoolVector self, std::vector< bool >::size_type n, std::vector< bool >::value_type x)"},
	 { "BoolVector_resize", _wrap_BoolVector_resize, METH_VARARGS, "\n"
		"BoolVector_resize(BoolVector self, std::vector< bool >::size_type new_size)\n"
		"BoolVector_resize(BoolVector self, std::vector< bool >::size_type new_size, std::vector< bool >::value_type x)\n"
		""},
	 { "BoolVector_insert", _wrap_BoolVector_insert, METH_VARARGS, "\n"
		"BoolVector_insert(BoolVector self, std::vector< bool >::iterator pos, std::vector< bool >::value_type x) -> std::vector< bool >::iterator\n"
		"BoolVector_insert(BoolVector self, std::vector< bool >::iterator pos, std::vector< bool >::size_type n, std::vector< bool >::value_type x)\n"
		""},
	 { "BoolVector_reserve", _wrap_BoolVector_reserve, METH_VARARGS, "BoolVector_reserve(BoolVector self, std::vector< bool >::size_type n)"},
	 { "BoolVector_capacity", _wrap_BoolVector_capacity, METH_O, "BoolVector_capacity(BoolVector self) -> std::vector< bool >::size_type"},
	 { "delete_BoolVector", _wrap_delete_BoolVector, METH_O, "delete_BoolVector(BoolVector self)"},
	 { "BoolVector_swigregister", BoolVector_swigregister, METH_O, NULL},
	 { "BoolVector_swiginit", BoolVector_swiginit, METH_VARARGS, NULL},
	 { "DoubleVectorVector_iterator", _wrap_DoubleVectorVector_iterator, METH_O, "DoubleVectorVector_iterator(DoubleVectorVector self) -> SwigPyIterator"},
	 { "DoubleVectorVector___nonzero__", _wrap_DoubleVectorVector___nonzero__, METH_O, "DoubleVectorVector___nonzero__(DoubleVectorVector self) -> bool"},
	 { "DoubleVectorVector___bool__", _wrap_DoubleVectorVector___bool__, METH_O, "DoubleVectorVector___bool__(DoubleVectorVector self) -> bool"},
	 { "DoubleVectorVector___len__", _wrap_DoubleVectorVector___len__, METH_O, "DoubleVectorVector___len__(DoubleVectorVector self) -> std::vector< std::vector< double > >::size_type"},
	 { "DoubleVectorVector___getslice__", _wrap_DoubleVectorVector___getslice__, METH_VARARGS, "DoubleVectorVector___getslice__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> DoubleVectorVector"},
	 { "DoubleVectorVector___setslice__", _wrap_DoubleVectorVector___setslice__, METH_VARARGS, "\n"
		"DoubleVectorVector___setslice__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
		"DoubleVectorVector___setslice__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, DoubleVectorVector v)\n"
		""},
	 { "DoubleVectorVector___delslice__", _wrap_DoubleVectorVector___delslice__, METH_VARARGS, "DoubleVectorVector___delslice__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
	 { "DoubleVectorVector___delitem__", _wrap_DoubleVectorVector___delitem__, METH_VARARGS, "\n"
		"DoubleVectorVector___delitem__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i)\n"
		"DoubleVectorVector___delitem__(DoubleVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "DoubleVectorVector___getitem__", _wrap_DoubleVectorVector___getitem__, METH_VARARGS, "\n"
		"DoubleVectorVector___getitem__(DoubleVectorVector self, SWIGPY_SLICEOBJECT * slice) -> DoubleVectorVector\n"
		"DoubleVectorVector___getitem__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i) -> DoubleVector\n"
		""},
	 { "DoubleVectorVector___setitem__", _wrap_DoubleVectorVector___setitem__, METH_VARARGS, "\n"
		"DoubleVectorVector___setitem__(DoubleVectorVector self, SWIGPY_SLICEOBJECT * slice, DoubleVectorVector v)\n"
		"DoubleVectorVector___setitem__(DoubleVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"DoubleVectorVector___setitem__(DoubleVectorVector self, std::vector< std::vector< double > >::difference_type i, DoubleVector x)\n"
		""},
	 { "DoubleVectorVector_pop", _wrap_DoubleVectorVector_pop, METH_O, "DoubleVectorVector_pop(DoubleVectorVector self) -> DoubleVector"},
	 { "DoubleVectorVector_append", _wrap_DoubleVectorVector_append, METH_VARARGS, "DoubleVectorVector_append(DoubleVectorVector self, DoubleVector x)"},
	 { "DoubleVectorVector_empty", _wrap_DoubleVectorVector_empty, METH_O, "DoubleVectorVector_empty(DoubleVectorVector self) -> bool"},
	 { "DoubleVectorVector_size", _wrap_DoubleVectorVector_size, METH_O, "DoubleVectorVector_size(DoubleVectorVector self) -> std::vector< std::vector< double > >::size_type"},
	 { "DoubleVectorVector_swap", _wrap_DoubleVectorVector_swap, METH_VARARGS, "DoubleVectorVector_swap(DoubleVectorVector self, DoubleVectorVector v)"},
	 { "DoubleVectorVector_begin", _wrap_DoubleVectorVector_begin, METH_O, "DoubleVectorVector_begin(DoubleVectorVector self) -> std::vector< std::vector< double > >::iterator"},
	 { "DoubleVectorVector_end", _wrap_DoubleVectorVector_end, METH_O, "DoubleVectorVector_end(DoubleVectorVector self) -> std::vector< std::vector< double > >::iterator"},
	 { "DoubleVectorVector_rbegin", _wrap_DoubleVectorVector_rbegin, METH_O, "DoubleVectorVector_rbegin(DoubleVectorVector self) -> std::vector< std::vector< double > >::reverse_iterator"},
	 { "DoubleVectorVector_rend", _wrap_DoubleVectorVector_rend, METH_O, "DoubleVectorVector_rend(DoubleVectorVector self) -> std::vector< std::vector< double > >::reverse_iterator"},
	 { "DoubleVectorVector_clear", _wrap_DoubleVectorVector_clear, METH_O, "DoubleVectorVector_clear(DoubleVectorVector self)"},
	 { "DoubleVectorVector_get_allocator", _wrap_DoubleVectorVector_get_allocator, METH_O, "DoubleVectorVector_get_allocator(DoubleVectorVector self) -> std::vector< std::vector< double > >::allocator_type"},
	 { "DoubleVectorVector_pop_back", _wrap_DoubleVectorVector_pop_back, METH_O, "DoubleVectorVector_pop_back(DoubleVectorVector self)"},
	 { "DoubleVectorVector_erase", _wrap_DoubleVectorVector_erase, METH_VARARGS, "\n"
		"DoubleVectorVector_erase(DoubleVectorVector self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator\n"
		"DoubleVectorVector_erase(DoubleVectorVector self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator\n"
		""},
	 { "new_DoubleVectorVector", _wrap_new_DoubleVectorVector, METH_VARARGS, "\n"
		"DoubleVectorVector()\n"
		"DoubleVectorVector(DoubleVectorVector other)\n"
		"DoubleVectorVector(std::vector< std::vector< double > >::size_type size)\n"
		"new_DoubleVectorVector(std::vector< std::vector< double > >::size_type size, DoubleVector value) -> DoubleVectorVector\n"
		""},
	 { "DoubleVectorVector_push_back", _wrap_DoubleVectorVector_push_back, METH_VARARGS, "DoubleVectorVector_push_back(DoubleVectorVector self, DoubleVector x)"},
	 { "DoubleVectorVector_front", _wrap_DoubleVectorVector_front, METH_O, "DoubleVectorVector_front(DoubleVectorVector self) -> DoubleVector"},
	 { "DoubleVectorVector_back", _wrap_DoubleVectorVector_back, METH_O, "DoubleVectorVector_back(DoubleVectorVector self) -> DoubleVector"},
	 { "DoubleVectorVector_assign", _wrap_DoubleVectorVector_assign, METH_VARARGS, "DoubleVectorVector_assign(DoubleVectorVector self, std::vector< std::vector< double > >::size_type n, DoubleVector x)"},
	 { "DoubleVectorVector_resize", _wrap_DoubleVectorVector_resize, METH_VARARGS, "\n"
		"DoubleVectorVector_resize(DoubleVectorVector self, std::vector< std::vector< double > >::size_type new_size)\n"
		"DoubleVectorVector_resize(DoubleVectorVector self, std::vector< std::vector< double > >::size_type new_size, DoubleVector x)\n"
		""},
	 { "DoubleVectorVector_insert", _wrap_DoubleVectorVector_insert, METH_VARARGS, "\n"
		"DoubleVectorVector_insert(DoubleVectorVector self, std::vector< std::vector< double > >::iterator pos, DoubleVector x) -> std::vector< std::vector< double > >::iterator\n"
		"DoubleVectorVector_insert(DoubleVectorVector self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, DoubleVector x)\n"
		""},
	 { "DoubleVectorVector_reserve", _wrap_DoubleVectorVector_reserve, METH_VARARGS, "DoubleVectorVector_reserve(DoubleVectorVector self, std::vector< std::vector< double > >::size_type n)"},
	 { "DoubleVectorVector_capacity", _wrap_DoubleVectorVector_capacity, METH_O, "DoubleVectorVector_capacity(DoubleVectorVector self) -> std::vector< std::vector< double > >::size_type"},
	 { "delete_DoubleVectorVector", _wrap_delete_DoubleVectorVector, METH_O, "delete_DoubleVectorVector(DoubleVectorVector self)"},
	 { "DoubleVectorVector_swigregister", DoubleVectorVector_swigregister, METH_O, NULL},
	 { "DoubleVectorVector_swiginit", DoubleVectorVector_swiginit, METH_VARARGS, NULL},
	 { "new_DoublePair", _wrap_new_DoublePair, METH_VARARGS, "\n"
		"DoublePair()\n"
		"DoublePair(double first, double second)\n"
		"new_DoublePair(DoublePair other) -> DoublePair\n"
		""},
	 { "DoublePair_first_set", _wrap_DoublePair_first_set, METH_VARARGS, "DoublePair_first_set(DoublePair self, double first)"},
	 { "DoublePair_first_get", _wrap_DoublePair_first_get, METH_O, "DoublePair_first_get(DoublePair self) -> double"},
	 { "DoublePair_second_set", _wrap_DoublePair_second_set, METH_VARARGS, "DoublePair_second_set(DoublePair self, double second)"},
	 { "DoublePair_second_get", _wrap_DoublePair_second_get, METH_O, "DoublePair_second_get(DoublePair self) -> double"},
	 { "delete_DoublePair", _wrap_delete_DoublePair, METH_O, "delete_DoublePair(DoublePair self)"},
	 { "DoublePair_swigregister", DoublePair_swigregister, METH_O, NULL},
	 { "DoublePair_swiginit", DoublePair_swiginit, METH_VARARGS, NULL},
	 { "DoublePairVector_iterator", _wrap_DoublePairVector_iterator, METH_O, "DoublePairVector_iterator(DoublePairVector self) -> SwigPyIterator"},
	 { "DoublePairVector___nonzero__", _wrap_DoublePairVector___nonzero__, METH_O, "DoublePairVector___nonzero__(DoublePairVector self) -> bool"},
	 { "DoublePairVector___bool__", _wrap_DoublePairVector___bool__, METH_O, "DoublePairVector___bool__(DoublePairVector self) -> bool"},
	 { "DoublePairVector___len__", _wrap_DoublePairVector___len__, METH_O, "DoublePairVector___len__(DoublePairVector self) -> std::vector< std::pair< double,double > >::size_type"},
	 { "DoublePairVector___getslice__", _wrap_DoublePairVector___getslice__, METH_VARARGS, "DoublePairVector___getslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j) -> DoublePairVector"},
	 { "DoublePairVector___setslice__", _wrap_DoublePairVector___setslice__, METH_VARARGS, "\n"
		"DoublePairVector___setslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)\n"
		"DoublePairVector___setslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j, DoublePairVector v)\n"
		""},
	 { "DoublePairVector___delslice__", _wrap_DoublePairVector___delslice__, METH_VARARGS, "DoublePairVector___delslice__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
	 { "DoublePairVector___delitem__", _wrap_DoublePairVector___delitem__, METH_VARARGS, "\n"
		"DoublePairVector___delitem__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i)\n"
		"DoublePairVector___delitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "DoublePairVector___getitem__", _wrap_DoublePairVector___getitem__, METH_VARARGS, "\n"
		"DoublePairVector___getitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice) -> DoublePairVector\n"
		"DoublePairVector___getitem__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i) -> DoublePair\n"
		""},
	 { "DoublePairVector___setitem__", _wrap_DoublePairVector___setitem__, METH_VARARGS, "\n"
		"DoublePairVector___setitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice, DoublePairVector v)\n"
		"DoublePairVector___setitem__(DoublePairVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"DoublePairVector___setitem__(DoublePairVector self, std::vector< std::pair< double,double > >::difference_type i, DoublePair x)\n"
		""},
	 { "DoublePairVector_pop", _wrap_DoublePairVector_pop, METH_O, "DoublePairVector_pop(DoublePairVector self) -> DoublePair"},
	 { "DoublePairVector_append", _wrap_DoublePairVector_append, METH_VARARGS, "DoublePairVector_append(DoublePairVector self, DoublePair x)"},
	 { "DoublePairVector_empty", _wrap_DoublePairVector_empty, METH_O, "DoublePairVector_empty(DoublePairVector self) -> bool"},
	 { "DoublePairVector_size", _wrap_DoublePairVector_size, METH_O, "DoublePairVector_size(DoublePairVector self) -> std::vector< std::pair< double,double > >::size_type"},
	 { "DoublePairVector_swap", _wrap_DoublePairVector_swap, METH_VARARGS, "DoublePairVector_swap(DoublePairVector self, DoublePairVector v)"},
	 { "DoublePairVector_begin", _wrap_DoublePairVector_begin, METH_O, "DoublePairVector_begin(DoublePairVector self) -> std::vector< std::pair< double,double > >::iterator"},
	 { "DoublePairVector_end", _wrap_DoublePairVector_end, METH_O, "DoublePairVector_end(DoublePairVector self) -> std::vector< std::pair< double,double > >::iterator"},
	 { "DoublePairVector_rbegin", _wrap_DoublePairVector_rbegin, METH_O, "DoublePairVector_rbegin(DoublePairVector self) -> std::vector< std::pair< double,double > >::reverse_iterator"},
	 { "DoublePairVector_rend", _wrap_DoublePairVector_rend, METH_O, "DoublePairVector_rend(DoublePairVector self) -> std::vector< std::pair< double,double > >::reverse_iterator"},
	 { "DoublePairVector_clear", _wrap_DoublePairVector_clear, METH_O, "DoublePairVector_clear(DoublePairVector self)"},
	 { "DoublePairVector_get_allocator", _wrap_DoublePairVector_get_allocator, METH_O, "DoublePairVector_get_allocator(DoublePairVector self) -> std::vector< std::pair< double,double > >::allocator_type"},
	 { "DoublePairVector_pop_back", _wrap_DoublePairVector_pop_back, METH_O, "DoublePairVector_pop_back(DoublePairVector self)"},
	 { "DoublePairVector_erase", _wrap_DoublePairVector_erase, METH_VARARGS, "\n"
		"DoublePairVector_erase(DoublePairVector self, std::vector< std::pair< double,double > >::iterator pos) -> std::vector< std::pair< double,double > >::iterator\n"
		"DoublePairVector_erase(DoublePairVector self, std::vector< std::pair< double,double > >::iterator first, std::vector< std::pair< double,double > >::iterator last) -> std::vector< std::pair< double,double > >::iterator\n"
		""},
	 { "new_DoublePairVector", _wrap_new_DoublePairVector, METH_VARARGS, "\n"
		"DoublePairVector()\n"
		"DoublePairVector(DoublePairVector other)\n"
		"DoublePairVector(std::vector< std::pair< double,double > >::size_type size)\n"
		"new_DoublePairVector(std::vector< std::pair< double,double > >::size_type size, DoublePair value) -> DoublePairVector\n"
		""},
	 { "DoublePairVector_push_back", _wrap_DoublePairVector_push_back, METH_VARARGS, "DoublePairVector_push_back(DoublePairVector self, DoublePair x)"},
	 { "DoublePairVector_front", _wrap_DoublePairVector_front, METH_O, "DoublePairVector_front(DoublePairVector self) -> DoublePair"},
	 { "DoublePairVector_back", _wrap_DoublePairVector_back, METH_O, "DoublePairVector_back(DoublePairVector self) -> DoublePair"},
	 { "DoublePairVector_assign", _wrap_DoublePairVector_assign, METH_VARARGS, "DoublePairVector_assign(DoublePairVector self, std::vector< std::pair< double,double > >::size_type n, DoublePair x)"},
	 { "DoublePairVector_resize", _wrap_DoublePairVector_resize, METH_VARARGS, "\n"
		"DoublePairVector_resize(DoublePairVector self, std::vector< std::pair< double,double > >::size_type new_size)\n"
		"DoublePairVector_resize(DoublePairVector self, std::vector< std::pair< double,double > >::size_type new_size, DoublePair x)\n"
		""},
	 { "DoublePairVector_insert", _wrap_DoublePairVector_insert, METH_VARARGS, "\n"
		"DoublePairVector_insert(DoublePairVector self, std::vector< std::pair< double,double > >::iterator pos, DoublePair x) -> std::vector< std::pair< double,double > >::iterator\n"
		"DoublePairVector_insert(DoublePairVector self, std::vector< std::pair< double,double > >::iterator pos, std::vector< std::pair< double,double > >::size_type n, DoublePair x)\n"
		""},
	 { "DoublePairVector_reserve", _wrap_DoublePairVector_reserve, METH_VARARGS, "DoublePairVector_reserve(DoublePairVector self, std::vector< std::pair< double,double > >::size_type n)"},
	 { "DoublePairVector_capacity", _wrap_DoublePairVector_capacity, METH_O, "DoublePairVector_capacity(DoublePairVector self) -> std::vector< std::pair< double,double > >::size_type"},
	 { "delete_DoublePairVector", _wrap_delete_DoublePairVector, METH_O, "delete_DoublePairVector(DoublePairVector self)"},
	 { "DoublePairVector_swigregister", DoublePairVector_swigregister, METH_O, NULL},
	 { "DoublePairVector_swiginit", DoublePairVector_swiginit, METH_VARARGS, NULL},
	 { "new_PairDoubleVector", _wrap_new_PairDoubleVector, METH_VARARGS, "\n"
		"PairDoubleVector()\n"
		"PairDoubleVector(DoubleVector first, DoubleVector second)\n"
		"new_PairDoubleVector(PairDoubleVector other) -> PairDoubleVector\n"
		""},
	 { "PairDoubleVector_first_set", _wrap_PairDoubleVector_first_set, METH_VARARGS, "PairDoubleVector_first_set(PairDoubleVector self, DoubleVector first)"},
	 { "PairDoubleVector_first_get", _wrap_PairDoubleVector_first_get, METH_O, "PairDoubleVector_first_get(PairDoubleVector self) -> DoubleVector"},
	 { "PairDoubleVector_second_set", _wrap_PairDoubleVector_second_set, METH_VARARGS, "PairDoubleVector_second_set(PairDoubleVector self, DoubleVector second)"},
	 { "PairDoubleVector_second_get", _wrap_PairDoubleVector_second_get, METH_O, "PairDoubleVector_second_get(PairDoubleVector self) -> DoubleVector"},
	 { "delete_PairDoubleVector", _wrap_delete_PairDoubleVector, METH_O, "delete_PairDoubleVector(PairDoubleVector self)"},
	 { "PairDoubleVector_swigregister", PairDoubleVector_swigregister, METH_O, NULL},
	 { "PairDoubleVector_swiginit", PairDoubleVector_swiginit, METH_VARARGS, NULL},
	 { "new_UnsignedIntPair", _wrap_new_UnsignedIntPair, METH_VARARGS, "\n"
		"UnsignedIntPair()\n"
		"UnsignedIntPair(unsigned int first, unsigned int second)\n"
		"new_UnsignedIntPair(UnsignedIntPair other) -> UnsignedIntPair\n"
		""},
	 { "UnsignedIntPair_first_set", _wrap_UnsignedIntPair_first_set, METH_VARARGS, "UnsignedIntPair_first_set(UnsignedIntPair self, unsigned int first)"},
	 { "UnsignedIntPair_first_get", _wrap_UnsignedIntPair_first_get, METH_O, "UnsignedIntPair_first_get(UnsignedIntPair self) -> unsigned int"},
	 { "UnsignedIntPair_second_set", _wrap_UnsignedIntPair_second_set, METH_VARARGS, "UnsignedIntPair_second_set(UnsignedIntPair self, unsigned int second)"},
	 { "UnsignedIntPair_second_get", _wrap_UnsignedIntPair_second_get, METH_O, "UnsignedIntPair_second_get(UnsignedIntPair self) -> unsigned int"},
	 { "delete_UnsignedIntPair", _wrap_delete_UnsignedIntPair, METH_O, "delete_UnsignedIntPair(UnsignedIntPair self)"},
	 { "UnsignedIntPair_swigregister", UnsignedIntPair_swigregister, METH_O, NULL},
	 { "UnsignedIntPair_swiginit", UnsignedIntPair_swiginit, METH_VARARGS, NULL},
	 { "UnsignedIntPairVector_iterator", _wrap_UnsignedIntPairVector_iterator, METH_O, "UnsignedIntPairVector_iterator(UnsignedIntPairVector self) -> SwigPyIterator"},
	 { "UnsignedIntPairVector___nonzero__", _wrap_UnsignedIntPairVector___nonzero__, METH_O, "UnsignedIntPairVector___nonzero__(UnsignedIntPairVector self) -> bool"},
	 { "UnsignedIntPairVector___bool__", _wrap_UnsignedIntPairVector___bool__, METH_O, "UnsignedIntPairVector___bool__(UnsignedIntPairVector self) -> bool"},
	 { "UnsignedIntPairVector___len__", _wrap_UnsignedIntPairVector___len__, METH_O, "UnsignedIntPairVector___len__(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::size_type"},
	 { "UnsignedIntPairVector___getslice__", _wrap_UnsignedIntPairVector___getslice__, METH_VARARGS, "UnsignedIntPairVector___getslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j) -> UnsignedIntPairVector"},
	 { "UnsignedIntPairVector___setslice__", _wrap_UnsignedIntPairVector___setslice__, METH_VARARGS, "\n"
		"UnsignedIntPairVector___setslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j)\n"
		"UnsignedIntPairVector___setslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j, UnsignedIntPairVector v)\n"
		""},
	 { "UnsignedIntPairVector___delslice__", _wrap_UnsignedIntPairVector___delslice__, METH_VARARGS, "UnsignedIntPairVector___delslice__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, std::vector< std::pair< unsigned int,unsigned int > >::difference_type j)"},
	 { "UnsignedIntPairVector___delitem__", _wrap_UnsignedIntPairVector___delitem__, METH_VARARGS, "\n"
		"UnsignedIntPairVector___delitem__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i)\n"
		"UnsignedIntPairVector___delitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "UnsignedIntPairVector___getitem__", _wrap_UnsignedIntPairVector___getitem__, METH_VARARGS, "\n"
		"UnsignedIntPairVector___getitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice) -> UnsignedIntPairVector\n"
		"UnsignedIntPairVector___getitem__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i) -> UnsignedIntPair\n"
		""},
	 { "UnsignedIntPairVector___setitem__", _wrap_UnsignedIntPairVector___setitem__, METH_VARARGS, "\n"
		"UnsignedIntPairVector___setitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice, UnsignedIntPairVector v)\n"
		"UnsignedIntPairVector___setitem__(UnsignedIntPairVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"UnsignedIntPairVector___setitem__(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::difference_type i, UnsignedIntPair x)\n"
		""},
	 { "UnsignedIntPairVector_pop", _wrap_UnsignedIntPairVector_pop, METH_O, "UnsignedIntPairVector_pop(UnsignedIntPairVector self) -> UnsignedIntPair"},
	 { "UnsignedIntPairVector_append", _wrap_UnsignedIntPairVector_append, METH_VARARGS, "UnsignedIntPairVector_append(UnsignedIntPairVector self, UnsignedIntPair x)"},
	 { "UnsignedIntPairVector_empty", _wrap_UnsignedIntPairVector_empty, METH_O, "UnsignedIntPairVector_empty(UnsignedIntPairVector self) -> bool"},
	 { "UnsignedIntPairVector_size", _wrap_UnsignedIntPairVector_size, METH_O, "UnsignedIntPairVector_size(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::size_type"},
	 { "UnsignedIntPairVector_swap", _wrap_UnsignedIntPairVector_swap, METH_VARARGS, "UnsignedIntPairVector_swap(UnsignedIntPairVector self, UnsignedIntPairVector v)"},
	 { "UnsignedIntPairVector_begin", _wrap_UnsignedIntPairVector_begin, METH_O, "UnsignedIntPairVector_begin(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator"},
	 { "UnsignedIntPairVector_end", _wrap_UnsignedIntPairVector_end, METH_O, "UnsignedIntPairVector_end(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator"},
	 { "UnsignedIntPairVector_rbegin", _wrap_UnsignedIntPairVector_rbegin, METH_O, "UnsignedIntPairVector_rbegin(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator"},
	 { "UnsignedIntPairVector_rend", _wrap_UnsignedIntPairVector_rend, METH_O, "UnsignedIntPairVector_rend(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator"},
	 { "UnsignedIntPairVector_clear", _wrap_UnsignedIntPairVector_clear, METH_O, "UnsignedIntPairVector_clear(UnsignedIntPairVector self)"},
	 { "UnsignedIntPairVector_get_allocator", _wrap_UnsignedIntPairVector_get_allocator, METH_O, "UnsignedIntPairVector_get_allocator(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::allocator_type"},
	 { "UnsignedIntPairVector_pop_back", _wrap_UnsignedIntPairVector_pop_back, METH_O, "UnsignedIntPairVector_pop_back(UnsignedIntPairVector self)"},
	 { "UnsignedIntPairVector_erase", _wrap_UnsignedIntPairVector_erase, METH_VARARGS, "\n"
		"UnsignedIntPairVector_erase(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator pos) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator\n"
		"UnsignedIntPairVector_erase(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator first, std::vector< std::pair< unsigned int,unsigned int > >::iterator last) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator\n"
		""},
	 { "new_UnsignedIntPairVector", _wrap_new_UnsignedIntPairVector, METH_VARARGS, "\n"
		"UnsignedIntPairVector()\n"
		"UnsignedIntPairVector(UnsignedIntPairVector other)\n"
		"UnsignedIntPairVector(std::vector< std::pair< unsigned int,unsigned int > >::size_type size)\n"
		"new_UnsignedIntPairVector(std::vector< std::pair< unsigned int,unsigned int > >::size_type size, UnsignedIntPair value) -> UnsignedIntPairVector\n"
		""},
	 { "UnsignedIntPairVector_push_back", _wrap_UnsignedIntPairVector_push_back, METH_VARARGS, "UnsignedIntPairVector_push_back(UnsignedIntPairVector self, UnsignedIntPair x)"},
	 { "UnsignedIntPairVector_front", _wrap_UnsignedIntPairVector_front, METH_O, "UnsignedIntPairVector_front(UnsignedIntPairVector self) -> UnsignedIntPair"},
	 { "UnsignedIntPairVector_back", _wrap_UnsignedIntPairVector_back, METH_O, "UnsignedIntPairVector_back(UnsignedIntPairVector self) -> UnsignedIntPair"},
	 { "UnsignedIntPairVector_assign", _wrap_UnsignedIntPairVector_assign, METH_VARARGS, "UnsignedIntPairVector_assign(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type n, UnsignedIntPair x)"},
	 { "UnsignedIntPairVector_resize", _wrap_UnsignedIntPairVector_resize, METH_VARARGS, "\n"
		"UnsignedIntPairVector_resize(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type new_size)\n"
		"UnsignedIntPairVector_resize(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type new_size, UnsignedIntPair x)\n"
		""},
	 { "UnsignedIntPairVector_insert", _wrap_UnsignedIntPairVector_insert, METH_VARARGS, "\n"
		"UnsignedIntPairVector_insert(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator pos, UnsignedIntPair x) -> std::vector< std::pair< unsigned int,unsigned int > >::iterator\n"
		"UnsignedIntPairVector_insert(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::iterator pos, std::vector< std::pair< unsigned int,unsigned int > >::size_type n, UnsignedIntPair x)\n"
		""},
	 { "UnsignedIntPairVector_reserve", _wrap_UnsignedIntPairVector_reserve, METH_VARARGS, "UnsignedIntPairVector_reserve(UnsignedIntPairVector self, std::vector< std::pair< unsigned int,unsigned int > >::size_type n)"},
	 { "UnsignedIntPairVector_capacity", _wrap_UnsignedIntPairVector_capacity, METH_O, "UnsignedIntPairVector_capacity(UnsignedIntPairVector self) -> std::vector< std::pair< unsigned int,unsigned int > >::size_type"},
	 { "delete_UnsignedIntPairVector", _wrap_delete_UnsignedIntPairVector, METH_O, "delete_UnsignedIntPairVector(UnsignedIntPairVector self)"},
	 { "UnsignedIntPairVector_swigregister", UnsignedIntPairVector_swigregister, METH_O, NULL},
	 { "UnsignedIntPairVector_swiginit", UnsignedIntPairVector_swiginit, METH_VARARGS, NULL},
	 { "new_NodePair", _wrap_new_NodePair, METH_VARARGS, "\n"
		"NodePair()\n"
		"NodePair(Date first, double second)\n"
		"new_NodePair(NodePair other) -> NodePair\n"
		""},
	 { "NodePair_first_set", _wrap_NodePair_first_set, METH_VARARGS, "NodePair_first_set(NodePair self, Date first)"},
	 { "NodePair_first_get", _wrap_NodePair_first_get, METH_O, "NodePair_first_get(NodePair self) -> Date"},
	 { "NodePair_second_set", _wrap_NodePair_second_set, METH_VARARGS, "NodePair_second_set(NodePair self, double second)"},
	 { "NodePair_second_get", _wrap_NodePair_second_get, METH_O, "NodePair_second_get(NodePair self) -> double"},
	 { "delete_NodePair", _wrap_delete_NodePair, METH_O, "delete_NodePair(NodePair self)"},
	 { "NodePair_swigregister", NodePair_swigregister, METH_O, NULL},
	 { "NodePair_swiginit", NodePair_swiginit, METH_VARARGS, NULL},
	 { "NodeVector_iterator", _wrap_NodeVector_iterator, METH_O, "NodeVector_iterator(NodeVector self) -> SwigPyIterator"},
	 { "NodeVector___nonzero__", _wrap_NodeVector___nonzero__, METH_O, "NodeVector___nonzero__(NodeVector self) -> bool"},
	 { "NodeVector___bool__", _wrap_NodeVector___bool__, METH_O, "NodeVector___bool__(NodeVector self) -> bool"},
	 { "NodeVector___len__", _wrap_NodeVector___len__, METH_O, "NodeVector___len__(NodeVector self) -> std::vector< std::pair< Date,double > >::size_type"},
	 { "NodeVector___getslice__", _wrap_NodeVector___getslice__, METH_VARARGS, "NodeVector___getslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j) -> NodeVector"},
	 { "NodeVector___setslice__", _wrap_NodeVector___setslice__, METH_VARARGS, "\n"
		"NodeVector___setslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j)\n"
		"NodeVector___setslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j, NodeVector v)\n"
		""},
	 { "NodeVector___delslice__", _wrap_NodeVector___delslice__, METH_VARARGS, "NodeVector___delslice__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, std::vector< std::pair< Date,double > >::difference_type j)"},
	 { "NodeVector___delitem__", _wrap_NodeVector___delitem__, METH_VARARGS, "\n"
		"NodeVector___delitem__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i)\n"
		"NodeVector___delitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "NodeVector___getitem__", _wrap_NodeVector___getitem__, METH_VARARGS, "\n"
		"NodeVector___getitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice) -> NodeVector\n"
		"NodeVector___getitem__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i) -> NodePair\n"
		""},
	 { "NodeVector___setitem__", _wrap_NodeVector___setitem__, METH_VARARGS, "\n"
		"NodeVector___setitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice, NodeVector v)\n"
		"NodeVector___setitem__(NodeVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"NodeVector___setitem__(NodeVector self, std::vector< std::pair< Date,double > >::difference_type i, NodePair x)\n"
		""},
	 { "NodeVector_pop", _wrap_NodeVector_pop, METH_O, "NodeVector_pop(NodeVector self) -> NodePair"},
	 { "NodeVector_append", _wrap_NodeVector_append, METH_VARARGS, "NodeVector_append(NodeVector self, NodePair x)"},
	 { "NodeVector_empty", _wrap_NodeVector_empty, METH_O, "NodeVector_empty(NodeVector self) -> bool"},
	 { "NodeVector_size", _wrap_NodeVector_size, METH_O, "NodeVector_size(NodeVector self) -> std::vector< std::pair< Date,double > >::size_type"},
	 { "NodeVector_swap", _wrap_NodeVector_swap, METH_VARARGS, "NodeVector_swap(NodeVector self, NodeVector v)"},
	 { "NodeVector_begin", _wrap_NodeVector_begin, METH_O, "NodeVector_begin(NodeVector self) -> std::vector< std::pair< Date,double > >::iterator"},
	 { "NodeVector_end", _wrap_NodeVector_end, METH_O, "NodeVector_end(NodeVector self) -> std::vector< std::pair< Date,double > >::iterator"},
	 { "NodeVector_rbegin", _wrap_NodeVector_rbegin, METH_O, "NodeVector_rbegin(NodeVector self) -> std::vector< std::pair< Date,double > >::reverse_iterator"},
	 { "NodeVector_rend", _wrap_NodeVector_rend, METH_O, "NodeVector_rend(NodeVector self) -> std::vector< std::pair< Date,double > >::reverse_iterator"},
	 { "NodeVector_clear", _wrap_NodeVector_clear, METH_O, "NodeVector_clear(NodeVector self)"},
	 { "NodeVector_get_allocator", _wrap_NodeVector_get_allocator, METH_O, "NodeVector_get_allocator(NodeVector self) -> std::vector< std::pair< Date,double > >::allocator_type"},
	 { "NodeVector_pop_back", _wrap_NodeVector_pop_back, METH_O, "NodeVector_pop_back(NodeVector self)"},
	 { "NodeVector_erase", _wrap_NodeVector_erase, METH_VARARGS, "\n"
		"NodeVector_erase(NodeVector self, std::vector< std::pair< Date,double > >::iterator pos) -> std::vector< std::pair< Date,double > >::iterator\n"
		"NodeVector_erase(NodeVector self, std::vector< std::pair< Date,double > >::iterator first, std::vector< std::pair< Date,double > >::iterator last) -> std::vector< std::pair< Date,double > >::iterator\n"
		""},
	 { "new_NodeVector", _wrap_new_NodeVector, METH_VARARGS, "\n"
		"NodeVector()\n"
		"NodeVector(NodeVector other)\n"
		"NodeVector(std::vector< std::pair< Date,double > >::size_type size)\n"
		"new_NodeVector(std::vector< std::pair< Date,double > >::size_type size, NodePair value) -> NodeVector\n"
		""},
	 { "NodeVector_push_back", _wrap_NodeVector_push_back, METH_VARARGS, "NodeVector_push_back(NodeVector self, NodePair x)"},
	 { "NodeVector_front", _wrap_NodeVector_front, METH_O, "NodeVector_front(NodeVector self) -> NodePair"},
	 { "NodeVector_back", _wrap_NodeVector_back, METH_O, "NodeVector_back(NodeVector self) -> NodePair"},
	 { "NodeVector_assign", _wrap_NodeVector_assign, METH_VARARGS, "NodeVector_assign(NodeVector self, std::vector< std::pair< Date,double > >::size_type n, NodePair x)"},
	 { "NodeVector_resize", _wrap_NodeVector_resize, METH_VARARGS, "\n"
		"NodeVector_resize(NodeVector self, std::vector< std::pair< Date,double > >::size_type new_size)\n"
		"NodeVector_resize(NodeVector self, std::vector< std::pair< Date,double > >::size_type new_size, NodePair x)\n"
		""},
	 { "NodeVector_insert", _wrap_NodeVector_insert, METH_VARARGS, "\n"
		"NodeVector_insert(NodeVector self, std::vector< std::pair< Date,double > >::iterator pos, NodePair x) -> std::vector< std::pair< Date,double > >::iterator\n"
		"NodeVector_insert(NodeVector self, std::vector< std::pair< Date,double > >::iterator pos, std::vector< std::pair< Date,double > >::size_type n, NodePair x)\n"
		""},
	 { "NodeVector_reserve", _wrap_NodeVector_reserve, METH_VARARGS, "NodeVector_reserve(NodeVector self, std::vector< std::pair< Date,double > >::size_type n)"},
	 { "NodeVector_capacity", _wrap_NodeVector_capacity, METH_O, "NodeVector_capacity(NodeVector self) -> std::vector< std::pair< Date,double > >::size_type"},
	 { "delete_NodeVector", _wrap_delete_NodeVector, METH_O, "delete_NodeVector(NodeVector self)"},
	 { "NodeVector_swigregister", NodeVector_swigregister, METH_O, NULL},
	 { "NodeVector_swiginit", NodeVector_swiginit, METH_VARARGS, NULL},
	 { "Calendar_isWeekend", _wrap_Calendar_isWeekend, METH_VARARGS, "Calendar_isWeekend(Calendar self, Weekday w) -> bool"},
	 { "Calendar_endOfMonth", _wrap_Calendar_endOfMonth, METH_VARARGS, "Calendar_endOfMonth(Calendar self, Date arg2) -> Date"},
	 { "Calendar_isBusinessDay", _wrap_Calendar_isBusinessDay, METH_VARARGS, "Calendar_isBusinessDay(Calendar self, Date arg2) -> bool"},
	 { "Calendar_isHoliday", _wrap_Calendar_isHoliday, METH_VARARGS, "Calendar_isHoliday(Calendar self, Date arg2) -> bool"},
	 { "Calendar_isEndOfMonth", _wrap_Calendar_isEndOfMonth, METH_VARARGS, "Calendar_isEndOfMonth(Calendar self, Date arg2) -> bool"},
	 { "Calendar_addHoliday", _wrap_Calendar_addHoliday, METH_VARARGS, "Calendar_addHoliday(Calendar self, Date arg2)"},
	 { "Calendar_removeHoliday", _wrap_Calendar_removeHoliday, METH_VARARGS, "Calendar_removeHoliday(Calendar self, Date arg2)"},
	 { "Calendar_resetAddedAndRemovedHolidays", _wrap_Calendar_resetAddedAndRemovedHolidays, METH_O, "Calendar_resetAddedAndRemovedHolidays(Calendar self)"},
	 { "Calendar_adjust", _wrap_Calendar_adjust, METH_VARARGS, "Calendar_adjust(Calendar self, Date d, BusinessDayConvention convention=QuantLib::Following) -> Date"},
	 { "Calendar_advance", _wrap_Calendar_advance, METH_VARARGS, "\n"
		"Calendar_advance(Calendar self, Date d, Integer n, TimeUnit unit, BusinessDayConvention convention=QuantLib::Following, bool endOfMonth=False) -> Date\n"
		"Calendar_advance(Calendar self, Date d, Period period, BusinessDayConvention convention=QuantLib::Following, bool endOfMonth=False) -> Date\n"
		""},
	 { "Calendar_businessDaysBetween", _wrap_Calendar_businessDaysBetween, METH_VARARGS, "Calendar_businessDaysBetween(Calendar self, Date _from, Date to, bool includeFirst=True, bool includeLast=False) -> BigInteger"},
	 { "Calendar_holidayList", _wrap_Calendar_holidayList, METH_VARARGS, "Calendar_holidayList(Calendar self, Date _from, Date to, bool includeWeekEnds=False) -> DateVector"},
	 { "Calendar_businessDayList", _wrap_Calendar_businessDayList, METH_VARARGS, "Calendar_businessDayList(Calendar self, Date _from, Date to) -> DateVector"},
	 { "Calendar_name", _wrap_Calendar_name, METH_O, "Calendar_name(Calendar self) -> std::string"},
	 { "Calendar___str__", _wrap_Calendar___str__, METH_O, "Calendar___str__(Calendar self) -> std::string"},
	 { "Calendar___eq__", _wrap_Calendar___eq__, METH_VARARGS, "Calendar___eq__(Calendar self, Calendar other) -> bool"},
	 { "Calendar___ne__", _wrap_Calendar___ne__, METH_VARARGS, "Calendar___ne__(Calendar self, Calendar other) -> bool"},
	 { "delete_Calendar", _wrap_delete_Calendar, METH_O, "delete_Calendar(Calendar self)"},
	 { "Calendar_swigregister", Calendar_swigregister, METH_O, NULL},
	 { "CalendarVector_iterator", _wrap_CalendarVector_iterator, METH_O, "CalendarVector_iterator(CalendarVector self) -> SwigPyIterator"},
	 { "CalendarVector___nonzero__", _wrap_CalendarVector___nonzero__, METH_O, "CalendarVector___nonzero__(CalendarVector self) -> bool"},
	 { "CalendarVector___bool__", _wrap_CalendarVector___bool__, METH_O, "CalendarVector___bool__(CalendarVector self) -> bool"},
	 { "CalendarVector___len__", _wrap_CalendarVector___len__, METH_O, "CalendarVector___len__(CalendarVector self) -> std::vector< Calendar >::size_type"},
	 { "CalendarVector___getslice__", _wrap_CalendarVector___getslice__, METH_VARARGS, "CalendarVector___getslice__(CalendarVector self, std::vector< Calendar >::difference_type i, std::vector< Calendar >::difference_type j) -> CalendarVector"},
	 { "CalendarVector___setslice__", _wrap_CalendarVector___setslice__, METH_VARARGS, "\n"
		"CalendarVector___setslice__(CalendarVector self, std::vector< Calendar >::difference_type i, std::vector< Calendar >::difference_type j)\n"
		"CalendarVector___setslice__(CalendarVector self, std::vector< Calendar >::difference_type i, std::vector< Calendar >::difference_type j, CalendarVector v)\n"
		""},
	 { "CalendarVector___delslice__", _wrap_CalendarVector___delslice__, METH_VARARGS, "CalendarVector___delslice__(CalendarVector self, std::vector< Calendar >::difference_type i, std::vector< Calendar >::difference_type j)"},
	 { "CalendarVector___delitem__", _wrap_CalendarVector___delitem__, METH_VARARGS, "\n"
		"CalendarVector___delitem__(CalendarVector self, std::vector< Calendar >::difference_type i)\n"
		"CalendarVector___delitem__(CalendarVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "CalendarVector___getitem__", _wrap_CalendarVector___getitem__, METH_VARARGS, "\n"
		"CalendarVector___getitem__(CalendarVector self, SWIGPY_SLICEOBJECT * slice) -> CalendarVector\n"
		"CalendarVector___getitem__(CalendarVector self, std::vector< Calendar >::difference_type i) -> Calendar\n"
		""},
	 { "CalendarVector___setitem__", _wrap_CalendarVector___setitem__, METH_VARARGS, "\n"
		"CalendarVector___setitem__(CalendarVector self, SWIGPY_SLICEOBJECT * slice, CalendarVector v)\n"
		"CalendarVector___setitem__(CalendarVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"CalendarVector___setitem__(CalendarVector self, std::vector< Calendar >::difference_type i, Calendar x)\n"
		""},
	 { "CalendarVector_pop", _wrap_CalendarVector_pop, METH_O, "CalendarVector_pop(CalendarVector self) -> Calendar"},
	 { "CalendarVector_append", _wrap_CalendarVector_append, METH_VARARGS, "CalendarVector_append(CalendarVector self, Calendar x)"},
	 { "CalendarVector_empty", _wrap_CalendarVector_empty, METH_O, "CalendarVector_empty(CalendarVector self) -> bool"},
	 { "CalendarVector_size", _wrap_CalendarVector_size, METH_O, "CalendarVector_size(CalendarVector self) -> std::vector< Calendar >::size_type"},
	 { "CalendarVector_swap", _wrap_CalendarVector_swap, METH_VARARGS, "CalendarVector_swap(CalendarVector self, CalendarVector v)"},
	 { "CalendarVector_begin", _wrap_CalendarVector_begin, METH_O, "CalendarVector_begin(CalendarVector self) -> std::vector< Calendar >::iterator"},
	 { "CalendarVector_end", _wrap_CalendarVector_end, METH_O, "CalendarVector_end(CalendarVector self) -> std::vector< Calendar >::iterator"},
	 { "CalendarVector_rbegin", _wrap_CalendarVector_rbegin, METH_O, "CalendarVector_rbegin(CalendarVector self) -> std::vector< Calendar >::reverse_iterator"},
	 { "CalendarVector_rend", _wrap_CalendarVector_rend, METH_O, "CalendarVector_rend(CalendarVector self) -> std::vector< Calendar >::reverse_iterator"},
	 { "CalendarVector_clear", _wrap_CalendarVector_clear, METH_O, "CalendarVector_clear(CalendarVector self)"},
	 { "CalendarVector_get_allocator", _wrap_CalendarVector_get_allocator, METH_O, "CalendarVector_get_allocator(CalendarVector self) -> std::vector< Calendar >::allocator_type"},
	 { "CalendarVector_pop_back", _wrap_CalendarVector_pop_back, METH_O, "CalendarVector_pop_back(CalendarVector self)"},
	 { "CalendarVector_erase", _wrap_CalendarVector_erase, METH_VARARGS, "\n"
		"CalendarVector_erase(CalendarVector self, std::vector< Calendar >::iterator pos) -> std::vector< Calendar >::iterator\n"
		"CalendarVector_erase(CalendarVector self, std::vector< Calendar >::iterator first, std::vector< Calendar >::iterator last) -> std::vector< Calendar >::iterator\n"
		""},
	 { "new_CalendarVector", _wrap_new_CalendarVector, METH_VARARGS, "\n"
		"CalendarVector()\n"
		"CalendarVector(CalendarVector other)\n"
		"CalendarVector(std::vector< Calendar >::size_type size)\n"
		"new_CalendarVector(std::vector< Calendar >::size_type size, Calendar value) -> CalendarVector\n"
		""},
	 { "CalendarVector_push_back", _wrap_CalendarVector_push_back, METH_VARARGS, "CalendarVector_push_back(CalendarVector self, Calendar x)"},
	 { "CalendarVector_front", _wrap_CalendarVector_front, METH_O, "CalendarVector_front(CalendarVector self) -> Calendar"},
	 { "CalendarVector_back", _wrap_CalendarVector_back, METH_O, "CalendarVector_back(CalendarVector self) -> Calendar"},
	 { "CalendarVector_assign", _wrap_CalendarVector_assign, METH_VARARGS, "CalendarVector_assign(CalendarVector self, std::vector< Calendar >::size_type n, Calendar x)"},
	 { "CalendarVector_resize", _wrap_CalendarVector_resize, METH_VARARGS, "\n"
		"CalendarVector_resize(CalendarVector self, std::vector< Calendar >::size_type new_size)\n"
		"CalendarVector_resize(CalendarVector self, std::vector< Calendar >::size_type new_size, Calendar x)\n"
		""},
	 { "CalendarVector_insert", _wrap_CalendarVector_insert, METH_VARARGS, "\n"
		"CalendarVector_insert(CalendarVector self, std::vector< Calendar >::iterator pos, Calendar x) -> std::vector< Calendar >::iterator\n"
		"CalendarVector_insert(CalendarVector self, std::vector< Calendar >::iterator pos, std::vector< Calendar >::size_type n, Calendar x)\n"
		""},
	 { "CalendarVector_reserve", _wrap_CalendarVector_reserve, METH_VARARGS, "CalendarVector_reserve(CalendarVector self, std::vector< Calendar >::size_type n)"},
	 { "CalendarVector_capacity", _wrap_CalendarVector_capacity, METH_O, "CalendarVector_capacity(CalendarVector self) -> std::vector< Calendar >::size_type"},
	 { "delete_CalendarVector", _wrap_delete_CalendarVector, METH_O, "delete_CalendarVector(CalendarVector self)"},
	 { "CalendarVector_swigregister", CalendarVector_swigregister, METH_O, NULL},
	 { "CalendarVector_swiginit", CalendarVector_swiginit, METH_VARARGS, NULL},
	 { "new_Argentina", _wrap_new_Argentina, METH_VARARGS, "Argentina(QuantLib::Argentina::Market m=Merval)"},
	 { "delete_Argentina", _wrap_delete_Argentina, METH_O, "delete_Argentina(Argentina self)"},
	 { "Argentina_swigregister", Argentina_swigregister, METH_O, NULL},
	 { "Argentina_swiginit", Argentina_swiginit, METH_VARARGS, NULL},
	 { "new_Australia", _wrap_new_Australia, METH_VARARGS, "Australia(QuantLib::Australia::Market market=Settlement)"},
	 { "delete_Australia", _wrap_delete_Australia, METH_O, "delete_Australia(Australia self)"},
	 { "Australia_swigregister", Australia_swigregister, METH_O, NULL},
	 { "Australia_swiginit", Australia_swiginit, METH_VARARGS, NULL},
	 { "new_Austria", _wrap_new_Austria, METH_VARARGS, "Austria(QuantLib::Austria::Market m=Settlement)"},
	 { "delete_Austria", _wrap_delete_Austria, METH_O, "delete_Austria(Austria self)"},
	 { "Austria_swigregister", Austria_swigregister, METH_O, NULL},
	 { "Austria_swiginit", Austria_swiginit, METH_VARARGS, NULL},
	 { "new_Botswana", _wrap_new_Botswana, METH_NOARGS, "new_Botswana() -> Botswana"},
	 { "delete_Botswana", _wrap_delete_Botswana, METH_O, "delete_Botswana(Botswana self)"},
	 { "Botswana_swigregister", Botswana_swigregister, METH_O, NULL},
	 { "Botswana_swiginit", Botswana_swiginit, METH_VARARGS, NULL},
	 { "new_Brazil", _wrap_new_Brazil, METH_VARARGS, "Brazil(QuantLib::Brazil::Market m=Settlement)"},
	 { "delete_Brazil", _wrap_delete_Brazil, METH_O, "delete_Brazil(Brazil self)"},
	 { "Brazil_swigregister", Brazil_swigregister, METH_O, NULL},
	 { "Brazil_swiginit", Brazil_swiginit, METH_VARARGS, NULL},
	 { "new_Canada", _wrap_new_Canada, METH_VARARGS, "Canada(QuantLib::Canada::Market m=Settlement)"},
	 { "delete_Canada", _wrap_delete_Canada, METH_O, "delete_Canada(Canada self)"},
	 { "Canada_swigregister", Canada_swigregister, METH_O, NULL},
	 { "Canada_swiginit", Canada_swiginit, METH_VARARGS, NULL},
	 { "new_Chile", _wrap_new_Chile, METH_VARARGS, "Chile(QuantLib::Chile::Market m=SSE)"},
	 { "delete_Chile", _wrap_delete_Chile, METH_O, "delete_Chile(Chile self)"},
	 { "Chile_swigregister", Chile_swigregister, METH_O, NULL},
	 { "Chile_swiginit", Chile_swiginit, METH_VARARGS, NULL},
	 { "new_China", _wrap_new_China, METH_VARARGS, "China(QuantLib::China::Market m=SSE)"},
	 { "delete_China", _wrap_delete_China, METH_O, "delete_China(China self)"},
	 { "China_swigregister", China_swigregister, METH_O, NULL},
	 { "China_swiginit", China_swiginit, METH_VARARGS, NULL},
	 { "new_CzechRepublic", _wrap_new_CzechRepublic, METH_VARARGS, "CzechRepublic(QuantLib::CzechRepublic::Market m=PSE)"},
	 { "delete_CzechRepublic", _wrap_delete_CzechRepublic, METH_O, "delete_CzechRepublic(CzechRepublic self)"},
	 { "CzechRepublic_swigregister", CzechRepublic_swigregister, METH_O, NULL},
	 { "CzechRepublic_swiginit", CzechRepublic_swiginit, METH_VARARGS, NULL},
	 { "new_Denmark", _wrap_new_Denmark, METH_NOARGS, "new_Denmark() -> Denmark"},
	 { "delete_Denmark", _wrap_delete_Denmark, METH_O, "delete_Denmark(Denmark self)"},
	 { "Denmark_swigregister", Denmark_swigregister, METH_O, NULL},
	 { "Denmark_swiginit", Denmark_swiginit, METH_VARARGS, NULL},
	 { "new_Finland", _wrap_new_Finland, METH_NOARGS, "new_Finland() -> Finland"},
	 { "delete_Finland", _wrap_delete_Finland, METH_O, "delete_Finland(Finland self)"},
	 { "Finland_swigregister", Finland_swigregister, METH_O, NULL},
	 { "Finland_swiginit", Finland_swiginit, METH_VARARGS, NULL},
	 { "new_France", _wrap_new_France, METH_VARARGS, "France(QuantLib::France::Market m=Settlement)"},
	 { "delete_France", _wrap_delete_France, METH_O, "delete_France(France self)"},
	 { "France_swigregister", France_swigregister, METH_O, NULL},
	 { "France_swiginit", France_swiginit, METH_VARARGS, NULL},
	 { "new_Germany", _wrap_new_Germany, METH_VARARGS, "Germany(QuantLib::Germany::Market m=FrankfurtStockExchange)"},
	 { "delete_Germany", _wrap_delete_Germany, METH_O, "delete_Germany(Germany self)"},
	 { "Germany_swigregister", Germany_swigregister, METH_O, NULL},
	 { "Germany_swiginit", Germany_swiginit, METH_VARARGS, NULL},
	 { "new_HongKong", _wrap_new_HongKong, METH_VARARGS, "HongKong(QuantLib::HongKong::Market m=HKEx)"},
	 { "delete_HongKong", _wrap_delete_HongKong, METH_O, "delete_HongKong(HongKong self)"},
	 { "HongKong_swigregister", HongKong_swigregister, METH_O, NULL},
	 { "HongKong_swiginit", HongKong_swiginit, METH_VARARGS, NULL},
	 { "new_Hungary", _wrap_new_Hungary, METH_NOARGS, "new_Hungary() -> Hungary"},
	 { "delete_Hungary", _wrap_delete_Hungary, METH_O, "delete_Hungary(Hungary self)"},
	 { "Hungary_swigregister", Hungary_swigregister, METH_O, NULL},
	 { "Hungary_swiginit", Hungary_swiginit, METH_VARARGS, NULL},
	 { "new_Iceland", _wrap_new_Iceland, METH_VARARGS, "Iceland(QuantLib::Iceland::Market m=ICEX)"},
	 { "delete_Iceland", _wrap_delete_Iceland, METH_O, "delete_Iceland(Iceland self)"},
	 { "Iceland_swigregister", Iceland_swigregister, METH_O, NULL},
	 { "Iceland_swiginit", Iceland_swiginit, METH_VARARGS, NULL},
	 { "new_India", _wrap_new_India, METH_VARARGS, "India(QuantLib::India::Market m=NSE)"},
	 { "delete_India", _wrap_delete_India, METH_O, "delete_India(India self)"},
	 { "India_swigregister", India_swigregister, METH_O, NULL},
	 { "India_swiginit", India_swiginit, METH_VARARGS, NULL},
	 { "new_Indonesia", _wrap_new_Indonesia, METH_VARARGS, "Indonesia(QuantLib::Indonesia::Market m=BEJ)"},
	 { "delete_Indonesia", _wrap_delete_Indonesia, METH_O, "delete_Indonesia(Indonesia self)"},
	 { "Indonesia_swigregister", Indonesia_swigregister, METH_O, NULL},
	 { "Indonesia_swiginit", Indonesia_swiginit, METH_VARARGS, NULL},
	 { "new_Israel", _wrap_new_Israel, METH_VARARGS, "Israel(QuantLib::Israel::Market m=Settlement)"},
	 { "delete_Israel", _wrap_delete_Israel, METH_O, "delete_Israel(Israel self)"},
	 { "Israel_swigregister", Israel_swigregister, METH_O, NULL},
	 { "Israel_swiginit", Israel_swiginit, METH_VARARGS, NULL},
	 { "new_Italy", _wrap_new_Italy, METH_VARARGS, "Italy(QuantLib::Italy::Market m=Settlement)"},
	 { "delete_Italy", _wrap_delete_Italy, METH_O, "delete_Italy(Italy self)"},
	 { "Italy_swigregister", Italy_swigregister, METH_O, NULL},
	 { "Italy_swiginit", Italy_swiginit, METH_VARARGS, NULL},
	 { "new_Japan", _wrap_new_Japan, METH_NOARGS, "new_Japan() -> Japan"},
	 { "delete_Japan", _wrap_delete_Japan, METH_O, "delete_Japan(Japan self)"},
	 { "Japan_swigregister", Japan_swigregister, METH_O, NULL},
	 { "Japan_swiginit", Japan_swiginit, METH_VARARGS, NULL},
	 { "new_Mexico", _wrap_new_Mexico, METH_VARARGS, "Mexico(QuantLib::Mexico::Market m=BMV)"},
	 { "delete_Mexico", _wrap_delete_Mexico, METH_O, "delete_Mexico(Mexico self)"},
	 { "Mexico_swigregister", Mexico_swigregister, METH_O, NULL},
	 { "Mexico_swiginit", Mexico_swiginit, METH_VARARGS, NULL},
	 { "new_NewZealand", _wrap_new_NewZealand, METH_NOARGS, "new_NewZealand() -> NewZealand"},
	 { "delete_NewZealand", _wrap_delete_NewZealand, METH_O, "delete_NewZealand(NewZealand self)"},
	 { "NewZealand_swigregister", NewZealand_swigregister, METH_O, NULL},
	 { "NewZealand_swiginit", NewZealand_swiginit, METH_VARARGS, NULL},
	 { "new_Norway", _wrap_new_Norway, METH_NOARGS, "new_Norway() -> Norway"},
	 { "delete_Norway", _wrap_delete_Norway, METH_O, "delete_Norway(Norway self)"},
	 { "Norway_swigregister", Norway_swigregister, METH_O, NULL},
	 { "Norway_swiginit", Norway_swiginit, METH_VARARGS, NULL},
	 { "new_Poland", _wrap_new_Poland, METH_NOARGS, "new_Poland() -> Poland"},
	 { "delete_Poland", _wrap_delete_Poland, METH_O, "delete_Poland(Poland self)"},
	 { "Poland_swigregister", Poland_swigregister, METH_O, NULL},
	 { "Poland_swiginit", Poland_swiginit, METH_VARARGS, NULL},
	 { "new_Romania", _wrap_new_Romania, METH_VARARGS, "Romania(QuantLib::Romania::Market m=BVB)"},
	 { "delete_Romania", _wrap_delete_Romania, METH_O, "delete_Romania(Romania self)"},
	 { "Romania_swigregister", Romania_swigregister, METH_O, NULL},
	 { "Romania_swiginit", Romania_swiginit, METH_VARARGS, NULL},
	 { "new_Russia", _wrap_new_Russia, METH_VARARGS, "Russia(QuantLib::Russia::Market m=Settlement)"},
	 { "delete_Russia", _wrap_delete_Russia, METH_O, "delete_Russia(Russia self)"},
	 { "Russia_swigregister", Russia_swigregister, METH_O, NULL},
	 { "Russia_swiginit", Russia_swiginit, METH_VARARGS, NULL},
	 { "new_SaudiArabia", _wrap_new_SaudiArabia, METH_VARARGS, "SaudiArabia(QuantLib::SaudiArabia::Market m=Tadawul)"},
	 { "delete_SaudiArabia", _wrap_delete_SaudiArabia, METH_O, "delete_SaudiArabia(SaudiArabia self)"},
	 { "SaudiArabia_swigregister", SaudiArabia_swigregister, METH_O, NULL},
	 { "SaudiArabia_swiginit", SaudiArabia_swiginit, METH_VARARGS, NULL},
	 { "new_Singapore", _wrap_new_Singapore, METH_VARARGS, "Singapore(QuantLib::Singapore::Market m=SGX)"},
	 { "delete_Singapore", _wrap_delete_Singapore, METH_O, "delete_Singapore(Singapore self)"},
	 { "Singapore_swigregister", Singapore_swigregister, METH_O, NULL},
	 { "Singapore_swiginit", Singapore_swiginit, METH_VARARGS, NULL},
	 { "new_Slovakia", _wrap_new_Slovakia, METH_VARARGS, "Slovakia(QuantLib::Slovakia::Market m=BSSE)"},
	 { "delete_Slovakia", _wrap_delete_Slovakia, METH_O, "delete_Slovakia(Slovakia self)"},
	 { "Slovakia_swigregister", Slovakia_swigregister, METH_O, NULL},
	 { "Slovakia_swiginit", Slovakia_swiginit, METH_VARARGS, NULL},
	 { "new_SouthAfrica", _wrap_new_SouthAfrica, METH_NOARGS, "new_SouthAfrica() -> SouthAfrica"},
	 { "delete_SouthAfrica", _wrap_delete_SouthAfrica, METH_O, "delete_SouthAfrica(SouthAfrica self)"},
	 { "SouthAfrica_swigregister", SouthAfrica_swigregister, METH_O, NULL},
	 { "SouthAfrica_swiginit", SouthAfrica_swiginit, METH_VARARGS, NULL},
	 { "new_SouthKorea", _wrap_new_SouthKorea, METH_VARARGS, "SouthKorea(QuantLib::SouthKorea::Market m=KRX)"},
	 { "delete_SouthKorea", _wrap_delete_SouthKorea, METH_O, "delete_SouthKorea(SouthKorea self)"},
	 { "SouthKorea_swigregister", SouthKorea_swigregister, METH_O, NULL},
	 { "SouthKorea_swiginit", SouthKorea_swiginit, METH_VARARGS, NULL},
	 { "new_Sweden", _wrap_new_Sweden, METH_NOARGS, "new_Sweden() -> Sweden"},
	 { "delete_Sweden", _wrap_delete_Sweden, METH_O, "delete_Sweden(Sweden self)"},
	 { "Sweden_swigregister", Sweden_swigregister, METH_O, NULL},
	 { "Sweden_swiginit", Sweden_swiginit, METH_VARARGS, NULL},
	 { "new_Switzerland", _wrap_new_Switzerland, METH_NOARGS, "new_Switzerland() -> Switzerland"},
	 { "delete_Switzerland", _wrap_delete_Switzerland, METH_O, "delete_Switzerland(Switzerland self)"},
	 { "Switzerland_swigregister", Switzerland_swigregister, METH_O, NULL},
	 { "Switzerland_swiginit", Switzerland_swiginit, METH_VARARGS, NULL},
	 { "new_Taiwan", _wrap_new_Taiwan, METH_VARARGS, "Taiwan(QuantLib::Taiwan::Market m=TSEC)"},
	 { "delete_Taiwan", _wrap_delete_Taiwan, METH_O, "delete_Taiwan(Taiwan self)"},
	 { "Taiwan_swigregister", Taiwan_swigregister, METH_O, NULL},
	 { "Taiwan_swiginit", Taiwan_swiginit, METH_VARARGS, NULL},
	 { "new_TARGET", _wrap_new_TARGET, METH_NOARGS, "new_TARGET() -> TARGET"},
	 { "delete_TARGET", _wrap_delete_TARGET, METH_O, "delete_TARGET(TARGET self)"},
	 { "TARGET_swigregister", TARGET_swigregister, METH_O, NULL},
	 { "TARGET_swiginit", TARGET_swiginit, METH_VARARGS, NULL},
	 { "new_Thailand", _wrap_new_Thailand, METH_NOARGS, "new_Thailand() -> Thailand"},
	 { "delete_Thailand", _wrap_delete_Thailand, METH_O, "delete_Thailand(Thailand self)"},
	 { "Thailand_swigregister", Thailand_swigregister, METH_O, NULL},
	 { "Thailand_swiginit", Thailand_swiginit, METH_VARARGS, NULL},
	 { "new_Turkey", _wrap_new_Turkey, METH_NOARGS, "new_Turkey() -> Turkey"},
	 { "delete_Turkey", _wrap_delete_Turkey, METH_O, "delete_Turkey(Turkey self)"},
	 { "Turkey_swigregister", Turkey_swigregister, METH_O, NULL},
	 { "Turkey_swiginit", Turkey_swiginit, METH_VARARGS, NULL},
	 { "new_Ukraine", _wrap_new_Ukraine, METH_VARARGS, "Ukraine(QuantLib::Ukraine::Market m=USE)"},
	 { "delete_Ukraine", _wrap_delete_Ukraine, METH_O, "delete_Ukraine(Ukraine self)"},
	 { "Ukraine_swigregister", Ukraine_swigregister, METH_O, NULL},
	 { "Ukraine_swiginit", Ukraine_swiginit, METH_VARARGS, NULL},
	 { "new_UnitedKingdom", _wrap_new_UnitedKingdom, METH_VARARGS, "UnitedKingdom(QuantLib::UnitedKingdom::Market m=Settlement)"},
	 { "delete_UnitedKingdom", _wrap_delete_UnitedKingdom, METH_O, "delete_UnitedKingdom(UnitedKingdom self)"},
	 { "UnitedKingdom_swigregister", UnitedKingdom_swigregister, METH_O, NULL},
	 { "UnitedKingdom_swiginit", UnitedKingdom_swiginit, METH_VARARGS, NULL},
	 { "new_UnitedStates", _wrap_new_UnitedStates, METH_O, "new_UnitedStates(QuantLib::UnitedStates::Market m) -> UnitedStates"},
	 { "delete_UnitedStates", _wrap_delete_UnitedStates, METH_O, "delete_UnitedStates(UnitedStates self)"},
	 { "UnitedStates_swigregister", UnitedStates_swigregister, METH_O, NULL},
	 { "UnitedStates_swiginit", UnitedStates_swiginit, METH_VARARGS, NULL},
	 { "new_NullCalendar", _wrap_new_NullCalendar, METH_NOARGS, "new_NullCalendar() -> NullCalendar"},
	 { "delete_NullCalendar", _wrap_delete_NullCalendar, METH_O, "delete_NullCalendar(NullCalendar self)"},
	 { "NullCalendar_swigregister", NullCalendar_swigregister, METH_O, NULL},
	 { "NullCalendar_swiginit", NullCalendar_swiginit, METH_VARARGS, NULL},
	 { "new_WeekendsOnly", _wrap_new_WeekendsOnly, METH_NOARGS, "new_WeekendsOnly() -> WeekendsOnly"},
	 { "delete_WeekendsOnly", _wrap_delete_WeekendsOnly, METH_O, "delete_WeekendsOnly(WeekendsOnly self)"},
	 { "WeekendsOnly_swigregister", WeekendsOnly_swigregister, METH_O, NULL},
	 { "WeekendsOnly_swiginit", WeekendsOnly_swiginit, METH_VARARGS, NULL},
	 { "new_JointCalendar", _wrap_new_JointCalendar, METH_VARARGS, "\n"
		"JointCalendar(Calendar arg1, Calendar arg2, JointCalendarRule rule=QuantLib::JoinHolidays)\n"
		"JointCalendar(Calendar arg1, Calendar arg2, Calendar arg3, JointCalendarRule rule=QuantLib::JoinHolidays)\n"
		"JointCalendar(Calendar arg1, Calendar arg2, Calendar arg3, Calendar arg4, JointCalendarRule rule=QuantLib::JoinHolidays)\n"
		"JointCalendar(CalendarVector arg1, JointCalendarRule arg2=QuantLib::JoinHolidays)\n"
		""},
	 { "delete_JointCalendar", _wrap_delete_JointCalendar, METH_O, "delete_JointCalendar(JointCalendar self)"},
	 { "JointCalendar_swigregister", JointCalendar_swigregister, METH_O, NULL},
	 { "JointCalendar_swiginit", JointCalendar_swiginit, METH_VARARGS, NULL},
	 { "new_BespokeCalendar", _wrap_new_BespokeCalendar, METH_O, "new_BespokeCalendar(std::string const & name) -> BespokeCalendar"},
	 { "BespokeCalendar_addWeekend", _wrap_BespokeCalendar_addWeekend, METH_VARARGS, "BespokeCalendar_addWeekend(BespokeCalendar self, Weekday arg2)"},
	 { "delete_BespokeCalendar", _wrap_delete_BespokeCalendar, METH_O, "delete_BespokeCalendar(BespokeCalendar self)"},
	 { "BespokeCalendar_swigregister", BespokeCalendar_swigregister, METH_O, NULL},
	 { "BespokeCalendar_swiginit", BespokeCalendar_swiginit, METH_VARARGS, NULL},
	 { "nullInt", _wrap_nullInt, METH_NOARGS, "nullInt() -> int"},
	 { "nullDouble", _wrap_nullDouble, METH_NOARGS, "nullDouble() -> double"},
	 { "DayCounter_dayCount", _wrap_DayCounter_dayCount, METH_VARARGS, "DayCounter_dayCount(DayCounter self, Date d1, Date d2) -> BigInteger"},
	 { "DayCounter_yearFraction", _wrap_DayCounter_yearFraction, METH_VARARGS, "DayCounter_yearFraction(DayCounter self, Date d1, Date d2, Date startRef=Date(), Date endRef=Date()) -> Time"},
	 { "DayCounter_name", _wrap_DayCounter_name, METH_O, "DayCounter_name(DayCounter self) -> std::string"},
	 { "DayCounter___str__", _wrap_DayCounter___str__, METH_O, "DayCounter___str__(DayCounter self) -> std::string"},
	 { "DayCounter___eq__", _wrap_DayCounter___eq__, METH_VARARGS, "DayCounter___eq__(DayCounter self, DayCounter other) -> bool"},
	 { "DayCounter___ne__", _wrap_DayCounter___ne__, METH_VARARGS, "DayCounter___ne__(DayCounter self, DayCounter other) -> bool"},
	 { "delete_DayCounter", _wrap_delete_DayCounter, METH_O, "delete_DayCounter(DayCounter self)"},
	 { "DayCounter_swigregister", DayCounter_swigregister, METH_O, NULL},
	 { "new_Actual360", _wrap_new_Actual360, METH_VARARGS, "Actual360(bool const includeLastDay=False)"},
	 { "delete_Actual360", _wrap_delete_Actual360, METH_O, "delete_Actual360(Actual360 self)"},
	 { "Actual360_swigregister", Actual360_swigregister, METH_O, NULL},
	 { "Actual360_swiginit", Actual360_swiginit, METH_VARARGS, NULL},
	 { "new_Actual366", _wrap_new_Actual366, METH_VARARGS, "Actual366(bool const includeLastDay=False)"},
	 { "delete_Actual366", _wrap_delete_Actual366, METH_O, "delete_Actual366(Actual366 self)"},
	 { "Actual366_swigregister", Actual366_swigregister, METH_O, NULL},
	 { "Actual366_swiginit", Actual366_swiginit, METH_VARARGS, NULL},
	 { "new_Actual36525", _wrap_new_Actual36525, METH_VARARGS, "Actual36525(bool const includeLastDay=False)"},
	 { "delete_Actual36525", _wrap_delete_Actual36525, METH_O, "delete_Actual36525(Actual36525 self)"},
	 { "Actual36525_swigregister", Actual36525_swigregister, METH_O, NULL},
	 { "Actual36525_swiginit", Actual36525_swiginit, METH_VARARGS, NULL},
	 { "new_Actual364", _wrap_new_Actual364, METH_NOARGS, "new_Actual364() -> Actual364"},
	 { "delete_Actual364", _wrap_delete_Actual364, METH_O, "delete_Actual364(Actual364 self)"},
	 { "Actual364_swigregister", Actual364_swigregister, METH_O, NULL},
	 { "Actual364_swiginit", Actual364_swiginit, METH_VARARGS, NULL},
	 { "new_Actual365Fixed", _wrap_new_Actual365Fixed, METH_VARARGS, "Actual365Fixed(QuantLib::Actual365Fixed::Convention c=Standard)"},
	 { "delete_Actual365Fixed", _wrap_delete_Actual365Fixed, METH_O, "delete_Actual365Fixed(Actual365Fixed self)"},
	 { "Actual365Fixed_swigregister", Actual365Fixed_swigregister, METH_O, NULL},
	 { "Actual365Fixed_swiginit", Actual365Fixed_swiginit, METH_VARARGS, NULL},
	 { "new_Thirty360", _wrap_new_Thirty360, METH_VARARGS, "Thirty360(QuantLib::Thirty360::Convention c, Date terminationDate=Date())"},
	 { "delete_Thirty360", _wrap_delete_Thirty360, METH_O, "delete_Thirty360(Thirty360 self)"},
	 { "Thirty360_swigregister", Thirty360_swigregister, METH_O, NULL},
	 { "Thirty360_swiginit", Thirty360_swiginit, METH_VARARGS, NULL},
	 { "new_Thirty365", _wrap_new_Thirty365, METH_NOARGS, "new_Thirty365() -> Thirty365"},
	 { "delete_Thirty365", _wrap_delete_Thirty365, METH_O, "delete_Thirty365(Thirty365 self)"},
	 { "Thirty365_swigregister", Thirty365_swigregister, METH_O, NULL},
	 { "Thirty365_swiginit", Thirty365_swiginit, METH_VARARGS, NULL},
	 { "new_ActualActual", _wrap_new_ActualActual, METH_VARARGS, "ActualActual(QuantLib::ActualActual::Convention c, Schedule schedule=Schedule())"},
	 { "delete_ActualActual", _wrap_delete_ActualActual, METH_O, "delete_ActualActual(ActualActual self)"},
	 { "ActualActual_swigregister", ActualActual_swigregister, METH_O, NULL},
	 { "ActualActual_swiginit", ActualActual_swiginit, METH_VARARGS, NULL},
	 { "new_OneDayCounter", _wrap_new_OneDayCounter, METH_NOARGS, "new_OneDayCounter() -> OneDayCounter"},
	 { "delete_OneDayCounter", _wrap_delete_OneDayCounter, METH_O, "delete_OneDayCounter(OneDayCounter self)"},
	 { "OneDayCounter_swigregister", OneDayCounter_swigregister, METH_O, NULL},
	 { "OneDayCounter_swiginit", OneDayCounter_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleDayCounter", _wrap_new_SimpleDayCounter, METH_NOARGS, "new_SimpleDayCounter() -> SimpleDayCounter"},
	 { "delete_SimpleDayCounter", _wrap_delete_SimpleDayCounter, METH_O, "delete_SimpleDayCounter(SimpleDayCounter self)"},
	 { "SimpleDayCounter_swigregister", SimpleDayCounter_swigregister, METH_O, NULL},
	 { "SimpleDayCounter_swiginit", SimpleDayCounter_swiginit, METH_VARARGS, NULL},
	 { "new_Business252", _wrap_new_Business252, METH_VARARGS, "Business252(Calendar c=QuantLib::Brazil())"},
	 { "delete_Business252", _wrap_delete_Business252, METH_O, "delete_Business252(Business252 self)"},
	 { "Business252_swigregister", Business252_swigregister, METH_O, NULL},
	 { "Business252_swiginit", Business252_swiginit, METH_VARARGS, NULL},
	 { "yearFractionToDate", _wrap_yearFractionToDate, METH_VARARGS, "yearFractionToDate(DayCounter dayCounter, Date referenceDate, Time t) -> Date"},
	 { "new_Rounding", _wrap_new_Rounding, METH_NOARGS, "new_Rounding() -> Rounding"},
	 { "Rounding___call__", _wrap_Rounding___call__, METH_VARARGS, "Rounding___call__(Rounding self, Decimal value) -> Decimal"},
	 { "delete_Rounding", _wrap_delete_Rounding, METH_O, "delete_Rounding(Rounding self)"},
	 { "Rounding_swigregister", Rounding_swigregister, METH_O, NULL},
	 { "Rounding_swiginit", Rounding_swiginit, METH_VARARGS, NULL},
	 { "new_UpRounding", _wrap_new_UpRounding, METH_VARARGS, "UpRounding(Integer precision, Integer digit=5)"},
	 { "delete_UpRounding", _wrap_delete_UpRounding, METH_O, "delete_UpRounding(UpRounding self)"},
	 { "UpRounding_swigregister", UpRounding_swigregister, METH_O, NULL},
	 { "UpRounding_swiginit", UpRounding_swiginit, METH_VARARGS, NULL},
	 { "new_DownRounding", _wrap_new_DownRounding, METH_VARARGS, "DownRounding(Integer precision, Integer digit=5)"},
	 { "delete_DownRounding", _wrap_delete_DownRounding, METH_O, "delete_DownRounding(DownRounding self)"},
	 { "DownRounding_swigregister", DownRounding_swigregister, METH_O, NULL},
	 { "DownRounding_swiginit", DownRounding_swiginit, METH_VARARGS, NULL},
	 { "new_ClosestRounding", _wrap_new_ClosestRounding, METH_VARARGS, "ClosestRounding(Integer precision, Integer digit=5)"},
	 { "delete_ClosestRounding", _wrap_delete_ClosestRounding, METH_O, "delete_ClosestRounding(ClosestRounding self)"},
	 { "ClosestRounding_swigregister", ClosestRounding_swigregister, METH_O, NULL},
	 { "ClosestRounding_swiginit", ClosestRounding_swiginit, METH_VARARGS, NULL},
	 { "new_CeilingTruncation", _wrap_new_CeilingTruncation, METH_VARARGS, "CeilingTruncation(Integer precision, Integer digit=5)"},
	 { "delete_CeilingTruncation", _wrap_delete_CeilingTruncation, METH_O, "delete_CeilingTruncation(CeilingTruncation self)"},
	 { "CeilingTruncation_swigregister", CeilingTruncation_swigregister, METH_O, NULL},
	 { "CeilingTruncation_swiginit", CeilingTruncation_swiginit, METH_VARARGS, NULL},
	 { "new_FloorTruncation", _wrap_new_FloorTruncation, METH_VARARGS, "FloorTruncation(Integer precision, Integer digit=5)"},
	 { "delete_FloorTruncation", _wrap_delete_FloorTruncation, METH_O, "delete_FloorTruncation(FloorTruncation self)"},
	 { "FloorTruncation_swigregister", FloorTruncation_swigregister, METH_O, NULL},
	 { "FloorTruncation_swiginit", FloorTruncation_swiginit, METH_VARARGS, NULL},
	 { "new_Currency", _wrap_new_Currency, METH_VARARGS, "\n"
		"Currency()\n"
		"Currency(std::string const & name, std::string const & code, Integer numericCode, std::string const & symbol, std::string const & fractionSymbol, Integer fractionsPerUnit, Rounding rounding, std::string const & formatString, Currency triangulationCurrency=Currency())\n"
		""},
	 { "Currency_name", _wrap_Currency_name, METH_O, "Currency_name(Currency self) -> std::string const &"},
	 { "Currency_code", _wrap_Currency_code, METH_O, "Currency_code(Currency self) -> std::string const &"},
	 { "Currency_numericCode", _wrap_Currency_numericCode, METH_O, "Currency_numericCode(Currency self) -> Integer"},
	 { "Currency_symbol", _wrap_Currency_symbol, METH_O, "Currency_symbol(Currency self) -> std::string const &"},
	 { "Currency_fractionSymbol", _wrap_Currency_fractionSymbol, METH_O, "Currency_fractionSymbol(Currency self) -> std::string const &"},
	 { "Currency_fractionsPerUnit", _wrap_Currency_fractionsPerUnit, METH_O, "Currency_fractionsPerUnit(Currency self) -> Integer"},
	 { "Currency_rounding", _wrap_Currency_rounding, METH_O, "Currency_rounding(Currency self) -> Rounding"},
	 { "Currency_format", _wrap_Currency_format, METH_O, "Currency_format(Currency self) -> std::string"},
	 { "Currency_empty", _wrap_Currency_empty, METH_O, "Currency_empty(Currency self) -> bool"},
	 { "Currency_triangulationCurrency", _wrap_Currency_triangulationCurrency, METH_O, "Currency_triangulationCurrency(Currency self) -> Currency"},
	 { "Currency___str__", _wrap_Currency___str__, METH_O, "Currency___str__(Currency self) -> std::string"},
	 { "Currency___eq__", _wrap_Currency___eq__, METH_VARARGS, "Currency___eq__(Currency self, Currency other) -> bool"},
	 { "Currency___ne__", _wrap_Currency___ne__, METH_VARARGS, "Currency___ne__(Currency self, Currency other) -> bool"},
	 { "Currency___mul__", _wrap_Currency___mul__, METH_VARARGS, "Currency___mul__(Currency self, Decimal x) -> Money"},
	 { "Currency___rmul__", _wrap_Currency___rmul__, METH_VARARGS, "Currency___rmul__(Currency self, Decimal x) -> Money"},
	 { "Currency___nonzero__", _wrap_Currency___nonzero__, METH_O, "Currency___nonzero__(Currency self) -> bool"},
	 { "Currency___bool__", _wrap_Currency___bool__, METH_O, "Currency___bool__(Currency self) -> bool"},
	 { "delete_Currency", _wrap_delete_Currency, METH_O, "delete_Currency(Currency self)"},
	 { "Currency_swigregister", Currency_swigregister, METH_O, NULL},
	 { "Currency_swiginit", Currency_swiginit, METH_VARARGS, NULL},
	 { "new_AEDCurrency", _wrap_new_AEDCurrency, METH_NOARGS, "new_AEDCurrency() -> AEDCurrency"},
	 { "delete_AEDCurrency", _wrap_delete_AEDCurrency, METH_O, "delete_AEDCurrency(AEDCurrency self)"},
	 { "AEDCurrency_swigregister", AEDCurrency_swigregister, METH_O, NULL},
	 { "AEDCurrency_swiginit", AEDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_AOACurrency", _wrap_new_AOACurrency, METH_NOARGS, "new_AOACurrency() -> AOACurrency"},
	 { "delete_AOACurrency", _wrap_delete_AOACurrency, METH_O, "delete_AOACurrency(AOACurrency self)"},
	 { "AOACurrency_swigregister", AOACurrency_swigregister, METH_O, NULL},
	 { "AOACurrency_swiginit", AOACurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ARSCurrency", _wrap_new_ARSCurrency, METH_NOARGS, "new_ARSCurrency() -> ARSCurrency"},
	 { "delete_ARSCurrency", _wrap_delete_ARSCurrency, METH_O, "delete_ARSCurrency(ARSCurrency self)"},
	 { "ARSCurrency_swigregister", ARSCurrency_swigregister, METH_O, NULL},
	 { "ARSCurrency_swiginit", ARSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ATSCurrency", _wrap_new_ATSCurrency, METH_NOARGS, "new_ATSCurrency() -> ATSCurrency"},
	 { "delete_ATSCurrency", _wrap_delete_ATSCurrency, METH_O, "delete_ATSCurrency(ATSCurrency self)"},
	 { "ATSCurrency_swigregister", ATSCurrency_swigregister, METH_O, NULL},
	 { "ATSCurrency_swiginit", ATSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_AUDCurrency", _wrap_new_AUDCurrency, METH_NOARGS, "new_AUDCurrency() -> AUDCurrency"},
	 { "delete_AUDCurrency", _wrap_delete_AUDCurrency, METH_O, "delete_AUDCurrency(AUDCurrency self)"},
	 { "AUDCurrency_swigregister", AUDCurrency_swigregister, METH_O, NULL},
	 { "AUDCurrency_swiginit", AUDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BDTCurrency", _wrap_new_BDTCurrency, METH_NOARGS, "new_BDTCurrency() -> BDTCurrency"},
	 { "delete_BDTCurrency", _wrap_delete_BDTCurrency, METH_O, "delete_BDTCurrency(BDTCurrency self)"},
	 { "BDTCurrency_swigregister", BDTCurrency_swigregister, METH_O, NULL},
	 { "BDTCurrency_swiginit", BDTCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BEFCurrency", _wrap_new_BEFCurrency, METH_NOARGS, "new_BEFCurrency() -> BEFCurrency"},
	 { "delete_BEFCurrency", _wrap_delete_BEFCurrency, METH_O, "delete_BEFCurrency(BEFCurrency self)"},
	 { "BEFCurrency_swigregister", BEFCurrency_swigregister, METH_O, NULL},
	 { "BEFCurrency_swiginit", BEFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BHDCurrency", _wrap_new_BHDCurrency, METH_NOARGS, "new_BHDCurrency() -> BHDCurrency"},
	 { "delete_BHDCurrency", _wrap_delete_BHDCurrency, METH_O, "delete_BHDCurrency(BHDCurrency self)"},
	 { "BHDCurrency_swigregister", BHDCurrency_swigregister, METH_O, NULL},
	 { "BHDCurrency_swiginit", BHDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BGLCurrency", _wrap_new_BGLCurrency, METH_NOARGS, "new_BGLCurrency() -> BGLCurrency"},
	 { "delete_BGLCurrency", _wrap_delete_BGLCurrency, METH_O, "delete_BGLCurrency(BGLCurrency self)"},
	 { "BGLCurrency_swigregister", BGLCurrency_swigregister, METH_O, NULL},
	 { "BGLCurrency_swiginit", BGLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BGNCurrency", _wrap_new_BGNCurrency, METH_NOARGS, "new_BGNCurrency() -> BGNCurrency"},
	 { "delete_BGNCurrency", _wrap_delete_BGNCurrency, METH_O, "delete_BGNCurrency(BGNCurrency self)"},
	 { "BGNCurrency_swigregister", BGNCurrency_swigregister, METH_O, NULL},
	 { "BGNCurrency_swiginit", BGNCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BRLCurrency", _wrap_new_BRLCurrency, METH_NOARGS, "new_BRLCurrency() -> BRLCurrency"},
	 { "delete_BRLCurrency", _wrap_delete_BRLCurrency, METH_O, "delete_BRLCurrency(BRLCurrency self)"},
	 { "BRLCurrency_swigregister", BRLCurrency_swigregister, METH_O, NULL},
	 { "BRLCurrency_swiginit", BRLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BWPCurrency", _wrap_new_BWPCurrency, METH_NOARGS, "new_BWPCurrency() -> BWPCurrency"},
	 { "delete_BWPCurrency", _wrap_delete_BWPCurrency, METH_O, "delete_BWPCurrency(BWPCurrency self)"},
	 { "BWPCurrency_swigregister", BWPCurrency_swigregister, METH_O, NULL},
	 { "BWPCurrency_swiginit", BWPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BYRCurrency", _wrap_new_BYRCurrency, METH_NOARGS, "new_BYRCurrency() -> BYRCurrency"},
	 { "delete_BYRCurrency", _wrap_delete_BYRCurrency, METH_O, "delete_BYRCurrency(BYRCurrency self)"},
	 { "BYRCurrency_swigregister", BYRCurrency_swigregister, METH_O, NULL},
	 { "BYRCurrency_swiginit", BYRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CADCurrency", _wrap_new_CADCurrency, METH_NOARGS, "new_CADCurrency() -> CADCurrency"},
	 { "delete_CADCurrency", _wrap_delete_CADCurrency, METH_O, "delete_CADCurrency(CADCurrency self)"},
	 { "CADCurrency_swigregister", CADCurrency_swigregister, METH_O, NULL},
	 { "CADCurrency_swiginit", CADCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CHFCurrency", _wrap_new_CHFCurrency, METH_NOARGS, "new_CHFCurrency() -> CHFCurrency"},
	 { "delete_CHFCurrency", _wrap_delete_CHFCurrency, METH_O, "delete_CHFCurrency(CHFCurrency self)"},
	 { "CHFCurrency_swigregister", CHFCurrency_swigregister, METH_O, NULL},
	 { "CHFCurrency_swiginit", CHFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CLFCurrency", _wrap_new_CLFCurrency, METH_NOARGS, "new_CLFCurrency() -> CLFCurrency"},
	 { "delete_CLFCurrency", _wrap_delete_CLFCurrency, METH_O, "delete_CLFCurrency(CLFCurrency self)"},
	 { "CLFCurrency_swigregister", CLFCurrency_swigregister, METH_O, NULL},
	 { "CLFCurrency_swiginit", CLFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CLPCurrency", _wrap_new_CLPCurrency, METH_NOARGS, "new_CLPCurrency() -> CLPCurrency"},
	 { "delete_CLPCurrency", _wrap_delete_CLPCurrency, METH_O, "delete_CLPCurrency(CLPCurrency self)"},
	 { "CLPCurrency_swigregister", CLPCurrency_swigregister, METH_O, NULL},
	 { "CLPCurrency_swiginit", CLPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CNHCurrency", _wrap_new_CNHCurrency, METH_NOARGS, "new_CNHCurrency() -> CNHCurrency"},
	 { "delete_CNHCurrency", _wrap_delete_CNHCurrency, METH_O, "delete_CNHCurrency(CNHCurrency self)"},
	 { "CNHCurrency_swigregister", CNHCurrency_swigregister, METH_O, NULL},
	 { "CNHCurrency_swiginit", CNHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CNYCurrency", _wrap_new_CNYCurrency, METH_NOARGS, "new_CNYCurrency() -> CNYCurrency"},
	 { "delete_CNYCurrency", _wrap_delete_CNYCurrency, METH_O, "delete_CNYCurrency(CNYCurrency self)"},
	 { "CNYCurrency_swigregister", CNYCurrency_swigregister, METH_O, NULL},
	 { "CNYCurrency_swiginit", CNYCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_COPCurrency", _wrap_new_COPCurrency, METH_NOARGS, "new_COPCurrency() -> COPCurrency"},
	 { "delete_COPCurrency", _wrap_delete_COPCurrency, METH_O, "delete_COPCurrency(COPCurrency self)"},
	 { "COPCurrency_swigregister", COPCurrency_swigregister, METH_O, NULL},
	 { "COPCurrency_swiginit", COPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_COUCurrency", _wrap_new_COUCurrency, METH_NOARGS, "new_COUCurrency() -> COUCurrency"},
	 { "delete_COUCurrency", _wrap_delete_COUCurrency, METH_O, "delete_COUCurrency(COUCurrency self)"},
	 { "COUCurrency_swigregister", COUCurrency_swigregister, METH_O, NULL},
	 { "COUCurrency_swiginit", COUCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CYPCurrency", _wrap_new_CYPCurrency, METH_NOARGS, "new_CYPCurrency() -> CYPCurrency"},
	 { "delete_CYPCurrency", _wrap_delete_CYPCurrency, METH_O, "delete_CYPCurrency(CYPCurrency self)"},
	 { "CYPCurrency_swigregister", CYPCurrency_swigregister, METH_O, NULL},
	 { "CYPCurrency_swiginit", CYPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_CZKCurrency", _wrap_new_CZKCurrency, METH_NOARGS, "new_CZKCurrency() -> CZKCurrency"},
	 { "delete_CZKCurrency", _wrap_delete_CZKCurrency, METH_O, "delete_CZKCurrency(CZKCurrency self)"},
	 { "CZKCurrency_swigregister", CZKCurrency_swigregister, METH_O, NULL},
	 { "CZKCurrency_swiginit", CZKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_DEMCurrency", _wrap_new_DEMCurrency, METH_NOARGS, "new_DEMCurrency() -> DEMCurrency"},
	 { "delete_DEMCurrency", _wrap_delete_DEMCurrency, METH_O, "delete_DEMCurrency(DEMCurrency self)"},
	 { "DEMCurrency_swigregister", DEMCurrency_swigregister, METH_O, NULL},
	 { "DEMCurrency_swiginit", DEMCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_DKKCurrency", _wrap_new_DKKCurrency, METH_NOARGS, "new_DKKCurrency() -> DKKCurrency"},
	 { "delete_DKKCurrency", _wrap_delete_DKKCurrency, METH_O, "delete_DKKCurrency(DKKCurrency self)"},
	 { "DKKCurrency_swigregister", DKKCurrency_swigregister, METH_O, NULL},
	 { "DKKCurrency_swiginit", DKKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_EEKCurrency", _wrap_new_EEKCurrency, METH_NOARGS, "new_EEKCurrency() -> EEKCurrency"},
	 { "delete_EEKCurrency", _wrap_delete_EEKCurrency, METH_O, "delete_EEKCurrency(EEKCurrency self)"},
	 { "EEKCurrency_swigregister", EEKCurrency_swigregister, METH_O, NULL},
	 { "EEKCurrency_swiginit", EEKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_EGPCurrency", _wrap_new_EGPCurrency, METH_NOARGS, "new_EGPCurrency() -> EGPCurrency"},
	 { "delete_EGPCurrency", _wrap_delete_EGPCurrency, METH_O, "delete_EGPCurrency(EGPCurrency self)"},
	 { "EGPCurrency_swigregister", EGPCurrency_swigregister, METH_O, NULL},
	 { "EGPCurrency_swiginit", EGPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ESPCurrency", _wrap_new_ESPCurrency, METH_NOARGS, "new_ESPCurrency() -> ESPCurrency"},
	 { "delete_ESPCurrency", _wrap_delete_ESPCurrency, METH_O, "delete_ESPCurrency(ESPCurrency self)"},
	 { "ESPCurrency_swigregister", ESPCurrency_swigregister, METH_O, NULL},
	 { "ESPCurrency_swiginit", ESPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ETBCurrency", _wrap_new_ETBCurrency, METH_NOARGS, "new_ETBCurrency() -> ETBCurrency"},
	 { "delete_ETBCurrency", _wrap_delete_ETBCurrency, METH_O, "delete_ETBCurrency(ETBCurrency self)"},
	 { "ETBCurrency_swigregister", ETBCurrency_swigregister, METH_O, NULL},
	 { "ETBCurrency_swiginit", ETBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_EURCurrency", _wrap_new_EURCurrency, METH_NOARGS, "new_EURCurrency() -> EURCurrency"},
	 { "delete_EURCurrency", _wrap_delete_EURCurrency, METH_O, "delete_EURCurrency(EURCurrency self)"},
	 { "EURCurrency_swigregister", EURCurrency_swigregister, METH_O, NULL},
	 { "EURCurrency_swiginit", EURCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_FIMCurrency", _wrap_new_FIMCurrency, METH_NOARGS, "new_FIMCurrency() -> FIMCurrency"},
	 { "delete_FIMCurrency", _wrap_delete_FIMCurrency, METH_O, "delete_FIMCurrency(FIMCurrency self)"},
	 { "FIMCurrency_swigregister", FIMCurrency_swigregister, METH_O, NULL},
	 { "FIMCurrency_swiginit", FIMCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_FRFCurrency", _wrap_new_FRFCurrency, METH_NOARGS, "new_FRFCurrency() -> FRFCurrency"},
	 { "delete_FRFCurrency", _wrap_delete_FRFCurrency, METH_O, "delete_FRFCurrency(FRFCurrency self)"},
	 { "FRFCurrency_swigregister", FRFCurrency_swigregister, METH_O, NULL},
	 { "FRFCurrency_swiginit", FRFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_GELCurrency", _wrap_new_GELCurrency, METH_NOARGS, "new_GELCurrency() -> GELCurrency"},
	 { "delete_GELCurrency", _wrap_delete_GELCurrency, METH_O, "delete_GELCurrency(GELCurrency self)"},
	 { "GELCurrency_swigregister", GELCurrency_swigregister, METH_O, NULL},
	 { "GELCurrency_swiginit", GELCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_GBPCurrency", _wrap_new_GBPCurrency, METH_NOARGS, "new_GBPCurrency() -> GBPCurrency"},
	 { "delete_GBPCurrency", _wrap_delete_GBPCurrency, METH_O, "delete_GBPCurrency(GBPCurrency self)"},
	 { "GBPCurrency_swigregister", GBPCurrency_swigregister, METH_O, NULL},
	 { "GBPCurrency_swiginit", GBPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_GHSCurrency", _wrap_new_GHSCurrency, METH_NOARGS, "new_GHSCurrency() -> GHSCurrency"},
	 { "delete_GHSCurrency", _wrap_delete_GHSCurrency, METH_O, "delete_GHSCurrency(GHSCurrency self)"},
	 { "GHSCurrency_swigregister", GHSCurrency_swigregister, METH_O, NULL},
	 { "GHSCurrency_swiginit", GHSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_GRDCurrency", _wrap_new_GRDCurrency, METH_NOARGS, "new_GRDCurrency() -> GRDCurrency"},
	 { "delete_GRDCurrency", _wrap_delete_GRDCurrency, METH_O, "delete_GRDCurrency(GRDCurrency self)"},
	 { "GRDCurrency_swigregister", GRDCurrency_swigregister, METH_O, NULL},
	 { "GRDCurrency_swiginit", GRDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_HKDCurrency", _wrap_new_HKDCurrency, METH_NOARGS, "new_HKDCurrency() -> HKDCurrency"},
	 { "delete_HKDCurrency", _wrap_delete_HKDCurrency, METH_O, "delete_HKDCurrency(HKDCurrency self)"},
	 { "HKDCurrency_swigregister", HKDCurrency_swigregister, METH_O, NULL},
	 { "HKDCurrency_swiginit", HKDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_HRKCurrency", _wrap_new_HRKCurrency, METH_NOARGS, "new_HRKCurrency() -> HRKCurrency"},
	 { "delete_HRKCurrency", _wrap_delete_HRKCurrency, METH_O, "delete_HRKCurrency(HRKCurrency self)"},
	 { "HRKCurrency_swigregister", HRKCurrency_swigregister, METH_O, NULL},
	 { "HRKCurrency_swiginit", HRKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_HUFCurrency", _wrap_new_HUFCurrency, METH_NOARGS, "new_HUFCurrency() -> HUFCurrency"},
	 { "delete_HUFCurrency", _wrap_delete_HUFCurrency, METH_O, "delete_HUFCurrency(HUFCurrency self)"},
	 { "HUFCurrency_swigregister", HUFCurrency_swigregister, METH_O, NULL},
	 { "HUFCurrency_swiginit", HUFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IDRCurrency", _wrap_new_IDRCurrency, METH_NOARGS, "new_IDRCurrency() -> IDRCurrency"},
	 { "delete_IDRCurrency", _wrap_delete_IDRCurrency, METH_O, "delete_IDRCurrency(IDRCurrency self)"},
	 { "IDRCurrency_swigregister", IDRCurrency_swigregister, METH_O, NULL},
	 { "IDRCurrency_swiginit", IDRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IEPCurrency", _wrap_new_IEPCurrency, METH_NOARGS, "new_IEPCurrency() -> IEPCurrency"},
	 { "delete_IEPCurrency", _wrap_delete_IEPCurrency, METH_O, "delete_IEPCurrency(IEPCurrency self)"},
	 { "IEPCurrency_swigregister", IEPCurrency_swigregister, METH_O, NULL},
	 { "IEPCurrency_swiginit", IEPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ILSCurrency", _wrap_new_ILSCurrency, METH_NOARGS, "new_ILSCurrency() -> ILSCurrency"},
	 { "delete_ILSCurrency", _wrap_delete_ILSCurrency, METH_O, "delete_ILSCurrency(ILSCurrency self)"},
	 { "ILSCurrency_swigregister", ILSCurrency_swigregister, METH_O, NULL},
	 { "ILSCurrency_swiginit", ILSCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_INRCurrency", _wrap_new_INRCurrency, METH_NOARGS, "new_INRCurrency() -> INRCurrency"},
	 { "delete_INRCurrency", _wrap_delete_INRCurrency, METH_O, "delete_INRCurrency(INRCurrency self)"},
	 { "INRCurrency_swigregister", INRCurrency_swigregister, METH_O, NULL},
	 { "INRCurrency_swiginit", INRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IQDCurrency", _wrap_new_IQDCurrency, METH_NOARGS, "new_IQDCurrency() -> IQDCurrency"},
	 { "delete_IQDCurrency", _wrap_delete_IQDCurrency, METH_O, "delete_IQDCurrency(IQDCurrency self)"},
	 { "IQDCurrency_swigregister", IQDCurrency_swigregister, METH_O, NULL},
	 { "IQDCurrency_swiginit", IQDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_IRRCurrency", _wrap_new_IRRCurrency, METH_NOARGS, "new_IRRCurrency() -> IRRCurrency"},
	 { "delete_IRRCurrency", _wrap_delete_IRRCurrency, METH_O, "delete_IRRCurrency(IRRCurrency self)"},
	 { "IRRCurrency_swigregister", IRRCurrency_swigregister, METH_O, NULL},
	 { "IRRCurrency_swiginit", IRRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ISKCurrency", _wrap_new_ISKCurrency, METH_NOARGS, "new_ISKCurrency() -> ISKCurrency"},
	 { "delete_ISKCurrency", _wrap_delete_ISKCurrency, METH_O, "delete_ISKCurrency(ISKCurrency self)"},
	 { "ISKCurrency_swigregister", ISKCurrency_swigregister, METH_O, NULL},
	 { "ISKCurrency_swiginit", ISKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ITLCurrency", _wrap_new_ITLCurrency, METH_NOARGS, "new_ITLCurrency() -> ITLCurrency"},
	 { "delete_ITLCurrency", _wrap_delete_ITLCurrency, METH_O, "delete_ITLCurrency(ITLCurrency self)"},
	 { "ITLCurrency_swigregister", ITLCurrency_swigregister, METH_O, NULL},
	 { "ITLCurrency_swiginit", ITLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_JODCurrency", _wrap_new_JODCurrency, METH_NOARGS, "new_JODCurrency() -> JODCurrency"},
	 { "delete_JODCurrency", _wrap_delete_JODCurrency, METH_O, "delete_JODCurrency(JODCurrency self)"},
	 { "JODCurrency_swigregister", JODCurrency_swigregister, METH_O, NULL},
	 { "JODCurrency_swiginit", JODCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_JPYCurrency", _wrap_new_JPYCurrency, METH_NOARGS, "new_JPYCurrency() -> JPYCurrency"},
	 { "delete_JPYCurrency", _wrap_delete_JPYCurrency, METH_O, "delete_JPYCurrency(JPYCurrency self)"},
	 { "JPYCurrency_swigregister", JPYCurrency_swigregister, METH_O, NULL},
	 { "JPYCurrency_swiginit", JPYCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_KESCurrency", _wrap_new_KESCurrency, METH_NOARGS, "new_KESCurrency() -> KESCurrency"},
	 { "delete_KESCurrency", _wrap_delete_KESCurrency, METH_O, "delete_KESCurrency(KESCurrency self)"},
	 { "KESCurrency_swigregister", KESCurrency_swigregister, METH_O, NULL},
	 { "KESCurrency_swiginit", KESCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_KRWCurrency", _wrap_new_KRWCurrency, METH_NOARGS, "new_KRWCurrency() -> KRWCurrency"},
	 { "delete_KRWCurrency", _wrap_delete_KRWCurrency, METH_O, "delete_KRWCurrency(KRWCurrency self)"},
	 { "KRWCurrency_swigregister", KRWCurrency_swigregister, METH_O, NULL},
	 { "KRWCurrency_swiginit", KRWCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_KWDCurrency", _wrap_new_KWDCurrency, METH_NOARGS, "new_KWDCurrency() -> KWDCurrency"},
	 { "delete_KWDCurrency", _wrap_delete_KWDCurrency, METH_O, "delete_KWDCurrency(KWDCurrency self)"},
	 { "KWDCurrency_swigregister", KWDCurrency_swigregister, METH_O, NULL},
	 { "KWDCurrency_swiginit", KWDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_KZTCurrency", _wrap_new_KZTCurrency, METH_NOARGS, "new_KZTCurrency() -> KZTCurrency"},
	 { "delete_KZTCurrency", _wrap_delete_KZTCurrency, METH_O, "delete_KZTCurrency(KZTCurrency self)"},
	 { "KZTCurrency_swigregister", KZTCurrency_swigregister, METH_O, NULL},
	 { "KZTCurrency_swiginit", KZTCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LKRCurrency", _wrap_new_LKRCurrency, METH_NOARGS, "new_LKRCurrency() -> LKRCurrency"},
	 { "delete_LKRCurrency", _wrap_delete_LKRCurrency, METH_O, "delete_LKRCurrency(LKRCurrency self)"},
	 { "LKRCurrency_swigregister", LKRCurrency_swigregister, METH_O, NULL},
	 { "LKRCurrency_swiginit", LKRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LTLCurrency", _wrap_new_LTLCurrency, METH_NOARGS, "new_LTLCurrency() -> LTLCurrency"},
	 { "delete_LTLCurrency", _wrap_delete_LTLCurrency, METH_O, "delete_LTLCurrency(LTLCurrency self)"},
	 { "LTLCurrency_swigregister", LTLCurrency_swigregister, METH_O, NULL},
	 { "LTLCurrency_swiginit", LTLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LUFCurrency", _wrap_new_LUFCurrency, METH_NOARGS, "new_LUFCurrency() -> LUFCurrency"},
	 { "delete_LUFCurrency", _wrap_delete_LUFCurrency, METH_O, "delete_LUFCurrency(LUFCurrency self)"},
	 { "LUFCurrency_swigregister", LUFCurrency_swigregister, METH_O, NULL},
	 { "LUFCurrency_swiginit", LUFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LVLCurrency", _wrap_new_LVLCurrency, METH_NOARGS, "new_LVLCurrency() -> LVLCurrency"},
	 { "delete_LVLCurrency", _wrap_delete_LVLCurrency, METH_O, "delete_LVLCurrency(LVLCurrency self)"},
	 { "LVLCurrency_swigregister", LVLCurrency_swigregister, METH_O, NULL},
	 { "LVLCurrency_swiginit", LVLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MADCurrency", _wrap_new_MADCurrency, METH_NOARGS, "new_MADCurrency() -> MADCurrency"},
	 { "delete_MADCurrency", _wrap_delete_MADCurrency, METH_O, "delete_MADCurrency(MADCurrency self)"},
	 { "MADCurrency_swigregister", MADCurrency_swigregister, METH_O, NULL},
	 { "MADCurrency_swiginit", MADCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MTLCurrency", _wrap_new_MTLCurrency, METH_NOARGS, "new_MTLCurrency() -> MTLCurrency"},
	 { "delete_MTLCurrency", _wrap_delete_MTLCurrency, METH_O, "delete_MTLCurrency(MTLCurrency self)"},
	 { "MTLCurrency_swigregister", MTLCurrency_swigregister, METH_O, NULL},
	 { "MTLCurrency_swiginit", MTLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MURCurrency", _wrap_new_MURCurrency, METH_NOARGS, "new_MURCurrency() -> MURCurrency"},
	 { "delete_MURCurrency", _wrap_delete_MURCurrency, METH_O, "delete_MURCurrency(MURCurrency self)"},
	 { "MURCurrency_swigregister", MURCurrency_swigregister, METH_O, NULL},
	 { "MURCurrency_swiginit", MURCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MXNCurrency", _wrap_new_MXNCurrency, METH_NOARGS, "new_MXNCurrency() -> MXNCurrency"},
	 { "delete_MXNCurrency", _wrap_delete_MXNCurrency, METH_O, "delete_MXNCurrency(MXNCurrency self)"},
	 { "MXNCurrency_swigregister", MXNCurrency_swigregister, METH_O, NULL},
	 { "MXNCurrency_swiginit", MXNCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MXVCurrency", _wrap_new_MXVCurrency, METH_NOARGS, "new_MXVCurrency() -> MXVCurrency"},
	 { "delete_MXVCurrency", _wrap_delete_MXVCurrency, METH_O, "delete_MXVCurrency(MXVCurrency self)"},
	 { "MXVCurrency_swigregister", MXVCurrency_swigregister, METH_O, NULL},
	 { "MXVCurrency_swiginit", MXVCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_MYRCurrency", _wrap_new_MYRCurrency, METH_NOARGS, "new_MYRCurrency() -> MYRCurrency"},
	 { "delete_MYRCurrency", _wrap_delete_MYRCurrency, METH_O, "delete_MYRCurrency(MYRCurrency self)"},
	 { "MYRCurrency_swigregister", MYRCurrency_swigregister, METH_O, NULL},
	 { "MYRCurrency_swiginit", MYRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NGNCurrency", _wrap_new_NGNCurrency, METH_NOARGS, "new_NGNCurrency() -> NGNCurrency"},
	 { "delete_NGNCurrency", _wrap_delete_NGNCurrency, METH_O, "delete_NGNCurrency(NGNCurrency self)"},
	 { "NGNCurrency_swigregister", NGNCurrency_swigregister, METH_O, NULL},
	 { "NGNCurrency_swiginit", NGNCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NLGCurrency", _wrap_new_NLGCurrency, METH_NOARGS, "new_NLGCurrency() -> NLGCurrency"},
	 { "delete_NLGCurrency", _wrap_delete_NLGCurrency, METH_O, "delete_NLGCurrency(NLGCurrency self)"},
	 { "NLGCurrency_swigregister", NLGCurrency_swigregister, METH_O, NULL},
	 { "NLGCurrency_swiginit", NLGCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NOKCurrency", _wrap_new_NOKCurrency, METH_NOARGS, "new_NOKCurrency() -> NOKCurrency"},
	 { "delete_NOKCurrency", _wrap_delete_NOKCurrency, METH_O, "delete_NOKCurrency(NOKCurrency self)"},
	 { "NOKCurrency_swigregister", NOKCurrency_swigregister, METH_O, NULL},
	 { "NOKCurrency_swiginit", NOKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NPRCurrency", _wrap_new_NPRCurrency, METH_NOARGS, "new_NPRCurrency() -> NPRCurrency"},
	 { "delete_NPRCurrency", _wrap_delete_NPRCurrency, METH_O, "delete_NPRCurrency(NPRCurrency self)"},
	 { "NPRCurrency_swigregister", NPRCurrency_swigregister, METH_O, NULL},
	 { "NPRCurrency_swiginit", NPRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_NZDCurrency", _wrap_new_NZDCurrency, METH_NOARGS, "new_NZDCurrency() -> NZDCurrency"},
	 { "delete_NZDCurrency", _wrap_delete_NZDCurrency, METH_O, "delete_NZDCurrency(NZDCurrency self)"},
	 { "NZDCurrency_swigregister", NZDCurrency_swigregister, METH_O, NULL},
	 { "NZDCurrency_swiginit", NZDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_OMRCurrency", _wrap_new_OMRCurrency, METH_NOARGS, "new_OMRCurrency() -> OMRCurrency"},
	 { "delete_OMRCurrency", _wrap_delete_OMRCurrency, METH_O, "delete_OMRCurrency(OMRCurrency self)"},
	 { "OMRCurrency_swigregister", OMRCurrency_swigregister, METH_O, NULL},
	 { "OMRCurrency_swiginit", OMRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PEHCurrency", _wrap_new_PEHCurrency, METH_NOARGS, "new_PEHCurrency() -> PEHCurrency"},
	 { "delete_PEHCurrency", _wrap_delete_PEHCurrency, METH_O, "delete_PEHCurrency(PEHCurrency self)"},
	 { "PEHCurrency_swigregister", PEHCurrency_swigregister, METH_O, NULL},
	 { "PEHCurrency_swiginit", PEHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PEICurrency", _wrap_new_PEICurrency, METH_NOARGS, "new_PEICurrency() -> PEICurrency"},
	 { "delete_PEICurrency", _wrap_delete_PEICurrency, METH_O, "delete_PEICurrency(PEICurrency self)"},
	 { "PEICurrency_swigregister", PEICurrency_swigregister, METH_O, NULL},
	 { "PEICurrency_swiginit", PEICurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PENCurrency", _wrap_new_PENCurrency, METH_NOARGS, "new_PENCurrency() -> PENCurrency"},
	 { "delete_PENCurrency", _wrap_delete_PENCurrency, METH_O, "delete_PENCurrency(PENCurrency self)"},
	 { "PENCurrency_swigregister", PENCurrency_swigregister, METH_O, NULL},
	 { "PENCurrency_swiginit", PENCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PHPCurrency", _wrap_new_PHPCurrency, METH_NOARGS, "new_PHPCurrency() -> PHPCurrency"},
	 { "delete_PHPCurrency", _wrap_delete_PHPCurrency, METH_O, "delete_PHPCurrency(PHPCurrency self)"},
	 { "PHPCurrency_swigregister", PHPCurrency_swigregister, METH_O, NULL},
	 { "PHPCurrency_swiginit", PHPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PKRCurrency", _wrap_new_PKRCurrency, METH_NOARGS, "new_PKRCurrency() -> PKRCurrency"},
	 { "delete_PKRCurrency", _wrap_delete_PKRCurrency, METH_O, "delete_PKRCurrency(PKRCurrency self)"},
	 { "PKRCurrency_swigregister", PKRCurrency_swigregister, METH_O, NULL},
	 { "PKRCurrency_swiginit", PKRCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PLNCurrency", _wrap_new_PLNCurrency, METH_NOARGS, "new_PLNCurrency() -> PLNCurrency"},
	 { "delete_PLNCurrency", _wrap_delete_PLNCurrency, METH_O, "delete_PLNCurrency(PLNCurrency self)"},
	 { "PLNCurrency_swigregister", PLNCurrency_swigregister, METH_O, NULL},
	 { "PLNCurrency_swiginit", PLNCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_PTECurrency", _wrap_new_PTECurrency, METH_NOARGS, "new_PTECurrency() -> PTECurrency"},
	 { "delete_PTECurrency", _wrap_delete_PTECurrency, METH_O, "delete_PTECurrency(PTECurrency self)"},
	 { "PTECurrency_swigregister", PTECurrency_swigregister, METH_O, NULL},
	 { "PTECurrency_swiginit", PTECurrency_swiginit, METH_VARARGS, NULL},
	 { "new_QARCurrency", _wrap_new_QARCurrency, METH_NOARGS, "new_QARCurrency() -> QARCurrency"},
	 { "delete_QARCurrency", _wrap_delete_QARCurrency, METH_O, "delete_QARCurrency(QARCurrency self)"},
	 { "QARCurrency_swigregister", QARCurrency_swigregister, METH_O, NULL},
	 { "QARCurrency_swiginit", QARCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ROLCurrency", _wrap_new_ROLCurrency, METH_NOARGS, "new_ROLCurrency() -> ROLCurrency"},
	 { "delete_ROLCurrency", _wrap_delete_ROLCurrency, METH_O, "delete_ROLCurrency(ROLCurrency self)"},
	 { "ROLCurrency_swigregister", ROLCurrency_swigregister, METH_O, NULL},
	 { "ROLCurrency_swiginit", ROLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_RONCurrency", _wrap_new_RONCurrency, METH_NOARGS, "new_RONCurrency() -> RONCurrency"},
	 { "delete_RONCurrency", _wrap_delete_RONCurrency, METH_O, "delete_RONCurrency(RONCurrency self)"},
	 { "RONCurrency_swigregister", RONCurrency_swigregister, METH_O, NULL},
	 { "RONCurrency_swiginit", RONCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_RSDCurrency", _wrap_new_RSDCurrency, METH_NOARGS, "new_RSDCurrency() -> RSDCurrency"},
	 { "delete_RSDCurrency", _wrap_delete_RSDCurrency, METH_O, "delete_RSDCurrency(RSDCurrency self)"},
	 { "RSDCurrency_swigregister", RSDCurrency_swigregister, METH_O, NULL},
	 { "RSDCurrency_swiginit", RSDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_RUBCurrency", _wrap_new_RUBCurrency, METH_NOARGS, "new_RUBCurrency() -> RUBCurrency"},
	 { "delete_RUBCurrency", _wrap_delete_RUBCurrency, METH_O, "delete_RUBCurrency(RUBCurrency self)"},
	 { "RUBCurrency_swigregister", RUBCurrency_swigregister, METH_O, NULL},
	 { "RUBCurrency_swiginit", RUBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SARCurrency", _wrap_new_SARCurrency, METH_NOARGS, "new_SARCurrency() -> SARCurrency"},
	 { "delete_SARCurrency", _wrap_delete_SARCurrency, METH_O, "delete_SARCurrency(SARCurrency self)"},
	 { "SARCurrency_swigregister", SARCurrency_swigregister, METH_O, NULL},
	 { "SARCurrency_swiginit", SARCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SEKCurrency", _wrap_new_SEKCurrency, METH_NOARGS, "new_SEKCurrency() -> SEKCurrency"},
	 { "delete_SEKCurrency", _wrap_delete_SEKCurrency, METH_O, "delete_SEKCurrency(SEKCurrency self)"},
	 { "SEKCurrency_swigregister", SEKCurrency_swigregister, METH_O, NULL},
	 { "SEKCurrency_swiginit", SEKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SGDCurrency", _wrap_new_SGDCurrency, METH_NOARGS, "new_SGDCurrency() -> SGDCurrency"},
	 { "delete_SGDCurrency", _wrap_delete_SGDCurrency, METH_O, "delete_SGDCurrency(SGDCurrency self)"},
	 { "SGDCurrency_swigregister", SGDCurrency_swigregister, METH_O, NULL},
	 { "SGDCurrency_swiginit", SGDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SITCurrency", _wrap_new_SITCurrency, METH_NOARGS, "new_SITCurrency() -> SITCurrency"},
	 { "delete_SITCurrency", _wrap_delete_SITCurrency, METH_O, "delete_SITCurrency(SITCurrency self)"},
	 { "SITCurrency_swigregister", SITCurrency_swigregister, METH_O, NULL},
	 { "SITCurrency_swiginit", SITCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_SKKCurrency", _wrap_new_SKKCurrency, METH_NOARGS, "new_SKKCurrency() -> SKKCurrency"},
	 { "delete_SKKCurrency", _wrap_delete_SKKCurrency, METH_O, "delete_SKKCurrency(SKKCurrency self)"},
	 { "SKKCurrency_swigregister", SKKCurrency_swigregister, METH_O, NULL},
	 { "SKKCurrency_swiginit", SKKCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_THBCurrency", _wrap_new_THBCurrency, METH_NOARGS, "new_THBCurrency() -> THBCurrency"},
	 { "delete_THBCurrency", _wrap_delete_THBCurrency, METH_O, "delete_THBCurrency(THBCurrency self)"},
	 { "THBCurrency_swigregister", THBCurrency_swigregister, METH_O, NULL},
	 { "THBCurrency_swiginit", THBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TNDCurrency", _wrap_new_TNDCurrency, METH_NOARGS, "new_TNDCurrency() -> TNDCurrency"},
	 { "delete_TNDCurrency", _wrap_delete_TNDCurrency, METH_O, "delete_TNDCurrency(TNDCurrency self)"},
	 { "TNDCurrency_swigregister", TNDCurrency_swigregister, METH_O, NULL},
	 { "TNDCurrency_swiginit", TNDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TRLCurrency", _wrap_new_TRLCurrency, METH_NOARGS, "new_TRLCurrency() -> TRLCurrency"},
	 { "delete_TRLCurrency", _wrap_delete_TRLCurrency, METH_O, "delete_TRLCurrency(TRLCurrency self)"},
	 { "TRLCurrency_swigregister", TRLCurrency_swigregister, METH_O, NULL},
	 { "TRLCurrency_swiginit", TRLCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TRYCurrency", _wrap_new_TRYCurrency, METH_NOARGS, "new_TRYCurrency() -> TRYCurrency"},
	 { "delete_TRYCurrency", _wrap_delete_TRYCurrency, METH_O, "delete_TRYCurrency(TRYCurrency self)"},
	 { "TRYCurrency_swigregister", TRYCurrency_swigregister, METH_O, NULL},
	 { "TRYCurrency_swiginit", TRYCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TTDCurrency", _wrap_new_TTDCurrency, METH_NOARGS, "new_TTDCurrency() -> TTDCurrency"},
	 { "delete_TTDCurrency", _wrap_delete_TTDCurrency, METH_O, "delete_TTDCurrency(TTDCurrency self)"},
	 { "TTDCurrency_swigregister", TTDCurrency_swigregister, METH_O, NULL},
	 { "TTDCurrency_swiginit", TTDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_TWDCurrency", _wrap_new_TWDCurrency, METH_NOARGS, "new_TWDCurrency() -> TWDCurrency"},
	 { "delete_TWDCurrency", _wrap_delete_TWDCurrency, METH_O, "delete_TWDCurrency(TWDCurrency self)"},
	 { "TWDCurrency_swigregister", TWDCurrency_swigregister, METH_O, NULL},
	 { "TWDCurrency_swiginit", TWDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_UAHCurrency", _wrap_new_UAHCurrency, METH_NOARGS, "new_UAHCurrency() -> UAHCurrency"},
	 { "delete_UAHCurrency", _wrap_delete_UAHCurrency, METH_O, "delete_UAHCurrency(UAHCurrency self)"},
	 { "UAHCurrency_swigregister", UAHCurrency_swigregister, METH_O, NULL},
	 { "UAHCurrency_swiginit", UAHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_UGXCurrency", _wrap_new_UGXCurrency, METH_NOARGS, "new_UGXCurrency() -> UGXCurrency"},
	 { "delete_UGXCurrency", _wrap_delete_UGXCurrency, METH_O, "delete_UGXCurrency(UGXCurrency self)"},
	 { "UGXCurrency_swigregister", UGXCurrency_swigregister, METH_O, NULL},
	 { "UGXCurrency_swiginit", UGXCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_USDCurrency", _wrap_new_USDCurrency, METH_NOARGS, "new_USDCurrency() -> USDCurrency"},
	 { "delete_USDCurrency", _wrap_delete_USDCurrency, METH_O, "delete_USDCurrency(USDCurrency self)"},
	 { "USDCurrency_swigregister", USDCurrency_swigregister, METH_O, NULL},
	 { "USDCurrency_swiginit", USDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_UYUCurrency", _wrap_new_UYUCurrency, METH_NOARGS, "new_UYUCurrency() -> UYUCurrency"},
	 { "delete_UYUCurrency", _wrap_delete_UYUCurrency, METH_O, "delete_UYUCurrency(UYUCurrency self)"},
	 { "UYUCurrency_swigregister", UYUCurrency_swigregister, METH_O, NULL},
	 { "UYUCurrency_swiginit", UYUCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_VEBCurrency", _wrap_new_VEBCurrency, METH_NOARGS, "new_VEBCurrency() -> VEBCurrency"},
	 { "delete_VEBCurrency", _wrap_delete_VEBCurrency, METH_O, "delete_VEBCurrency(VEBCurrency self)"},
	 { "VEBCurrency_swigregister", VEBCurrency_swigregister, METH_O, NULL},
	 { "VEBCurrency_swiginit", VEBCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_VNDCurrency", _wrap_new_VNDCurrency, METH_NOARGS, "new_VNDCurrency() -> VNDCurrency"},
	 { "delete_VNDCurrency", _wrap_delete_VNDCurrency, METH_O, "delete_VNDCurrency(VNDCurrency self)"},
	 { "VNDCurrency_swigregister", VNDCurrency_swigregister, METH_O, NULL},
	 { "VNDCurrency_swiginit", VNDCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_XOFCurrency", _wrap_new_XOFCurrency, METH_NOARGS, "new_XOFCurrency() -> XOFCurrency"},
	 { "delete_XOFCurrency", _wrap_delete_XOFCurrency, METH_O, "delete_XOFCurrency(XOFCurrency self)"},
	 { "XOFCurrency_swigregister", XOFCurrency_swigregister, METH_O, NULL},
	 { "XOFCurrency_swiginit", XOFCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ZARCurrency", _wrap_new_ZARCurrency, METH_NOARGS, "new_ZARCurrency() -> ZARCurrency"},
	 { "delete_ZARCurrency", _wrap_delete_ZARCurrency, METH_O, "delete_ZARCurrency(ZARCurrency self)"},
	 { "ZARCurrency_swigregister", ZARCurrency_swigregister, METH_O, NULL},
	 { "ZARCurrency_swiginit", ZARCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ZMWCurrency", _wrap_new_ZMWCurrency, METH_NOARGS, "new_ZMWCurrency() -> ZMWCurrency"},
	 { "delete_ZMWCurrency", _wrap_delete_ZMWCurrency, METH_O, "delete_ZMWCurrency(ZMWCurrency self)"},
	 { "ZMWCurrency_swigregister", ZMWCurrency_swigregister, METH_O, NULL},
	 { "ZMWCurrency_swiginit", ZMWCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BCHCurrency", _wrap_new_BCHCurrency, METH_NOARGS, "new_BCHCurrency() -> BCHCurrency"},
	 { "delete_BCHCurrency", _wrap_delete_BCHCurrency, METH_O, "delete_BCHCurrency(BCHCurrency self)"},
	 { "BCHCurrency_swigregister", BCHCurrency_swigregister, METH_O, NULL},
	 { "BCHCurrency_swiginit", BCHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_BTCCurrency", _wrap_new_BTCCurrency, METH_NOARGS, "new_BTCCurrency() -> BTCCurrency"},
	 { "delete_BTCCurrency", _wrap_delete_BTCCurrency, METH_O, "delete_BTCCurrency(BTCCurrency self)"},
	 { "BTCCurrency_swigregister", BTCCurrency_swigregister, METH_O, NULL},
	 { "BTCCurrency_swiginit", BTCCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_DASHCurrency", _wrap_new_DASHCurrency, METH_NOARGS, "new_DASHCurrency() -> DASHCurrency"},
	 { "delete_DASHCurrency", _wrap_delete_DASHCurrency, METH_O, "delete_DASHCurrency(DASHCurrency self)"},
	 { "DASHCurrency_swigregister", DASHCurrency_swigregister, METH_O, NULL},
	 { "DASHCurrency_swiginit", DASHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ETCCurrency", _wrap_new_ETCCurrency, METH_NOARGS, "new_ETCCurrency() -> ETCCurrency"},
	 { "delete_ETCCurrency", _wrap_delete_ETCCurrency, METH_O, "delete_ETCCurrency(ETCCurrency self)"},
	 { "ETCCurrency_swigregister", ETCCurrency_swigregister, METH_O, NULL},
	 { "ETCCurrency_swiginit", ETCCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ETHCurrency", _wrap_new_ETHCurrency, METH_NOARGS, "new_ETHCurrency() -> ETHCurrency"},
	 { "delete_ETHCurrency", _wrap_delete_ETHCurrency, METH_O, "delete_ETHCurrency(ETHCurrency self)"},
	 { "ETHCurrency_swigregister", ETHCurrency_swigregister, METH_O, NULL},
	 { "ETHCurrency_swiginit", ETHCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_LTCCurrency", _wrap_new_LTCCurrency, METH_NOARGS, "new_LTCCurrency() -> LTCCurrency"},
	 { "delete_LTCCurrency", _wrap_delete_LTCCurrency, METH_O, "delete_LTCCurrency(LTCCurrency self)"},
	 { "LTCCurrency_swigregister", LTCCurrency_swigregister, METH_O, NULL},
	 { "LTCCurrency_swiginit", LTCCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_XRPCurrency", _wrap_new_XRPCurrency, METH_NOARGS, "new_XRPCurrency() -> XRPCurrency"},
	 { "delete_XRPCurrency", _wrap_delete_XRPCurrency, METH_O, "delete_XRPCurrency(XRPCurrency self)"},
	 { "XRPCurrency_swigregister", XRPCurrency_swigregister, METH_O, NULL},
	 { "XRPCurrency_swiginit", XRPCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_ZECCurrency", _wrap_new_ZECCurrency, METH_NOARGS, "new_ZECCurrency() -> ZECCurrency"},
	 { "delete_ZECCurrency", _wrap_delete_ZECCurrency, METH_O, "delete_ZECCurrency(ZECCurrency self)"},
	 { "ZECCurrency_swigregister", ZECCurrency_swigregister, METH_O, NULL},
	 { "ZECCurrency_swiginit", ZECCurrency_swiginit, METH_VARARGS, NULL},
	 { "new_InterestRate", _wrap_new_InterestRate, METH_VARARGS, "\n"
		"InterestRate()\n"
		"new_InterestRate(Rate r, DayCounter dc, Compounding comp, Frequency freq) -> InterestRate\n"
		""},
	 { "InterestRate_rate", _wrap_InterestRate_rate, METH_O, "InterestRate_rate(InterestRate self) -> Rate"},
	 { "InterestRate_dayCounter", _wrap_InterestRate_dayCounter, METH_O, "InterestRate_dayCounter(InterestRate self) -> DayCounter"},
	 { "InterestRate_compounding", _wrap_InterestRate_compounding, METH_O, "InterestRate_compounding(InterestRate self) -> Compounding"},
	 { "InterestRate_frequency", _wrap_InterestRate_frequency, METH_O, "InterestRate_frequency(InterestRate self) -> Frequency"},
	 { "InterestRate_discountFactor", _wrap_InterestRate_discountFactor, METH_VARARGS, "\n"
		"InterestRate_discountFactor(InterestRate self, Time t) -> DiscountFactor\n"
		"InterestRate_discountFactor(InterestRate self, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> DiscountFactor\n"
		""},
	 { "InterestRate_compoundFactor", _wrap_InterestRate_compoundFactor, METH_VARARGS, "\n"
		"InterestRate_compoundFactor(InterestRate self, Time t) -> Real\n"
		"InterestRate_compoundFactor(InterestRate self, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> Real\n"
		""},
	 { "InterestRate_impliedRate", _wrap_InterestRate_impliedRate, METH_VARARGS, "\n"
		"InterestRate_impliedRate(Real compound, DayCounter resultDC, Compounding comp, Frequency freq, Time t) -> InterestRate\n"
		"InterestRate_impliedRate(Real compound, DayCounter resultDC, Compounding comp, Frequency freq, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> InterestRate\n"
		""},
	 { "InterestRate_equivalentRate", _wrap_InterestRate_equivalentRate, METH_VARARGS, "\n"
		"InterestRate_equivalentRate(InterestRate self, Compounding comp, Frequency freq, Time t) -> InterestRate\n"
		"InterestRate_equivalentRate(InterestRate self, DayCounter resultDayCounter, Compounding comp, Frequency freq, Date d1, Date d2, Date refStart=Date(), Date refEnd=Date()) -> InterestRate\n"
		""},
	 { "InterestRate___str__", _wrap_InterestRate___str__, METH_O, "InterestRate___str__(InterestRate self) -> std::string"},
	 { "delete_InterestRate", _wrap_delete_InterestRate, METH_O, "delete_InterestRate(InterestRate self)"},
	 { "InterestRate_swigregister", InterestRate_swigregister, METH_O, NULL},
	 { "InterestRate_swiginit", InterestRate_swiginit, METH_VARARGS, NULL},
	 { "InterestRateVector_iterator", _wrap_InterestRateVector_iterator, METH_O, "InterestRateVector_iterator(InterestRateVector self) -> SwigPyIterator"},
	 { "InterestRateVector___nonzero__", _wrap_InterestRateVector___nonzero__, METH_O, "InterestRateVector___nonzero__(InterestRateVector self) -> bool"},
	 { "InterestRateVector___bool__", _wrap_InterestRateVector___bool__, METH_O, "InterestRateVector___bool__(InterestRateVector self) -> bool"},
	 { "InterestRateVector___len__", _wrap_InterestRateVector___len__, METH_O, "InterestRateVector___len__(InterestRateVector self) -> std::vector< InterestRate >::size_type"},
	 { "InterestRateVector___getslice__", _wrap_InterestRateVector___getslice__, METH_VARARGS, "InterestRateVector___getslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j) -> InterestRateVector"},
	 { "InterestRateVector___setslice__", _wrap_InterestRateVector___setslice__, METH_VARARGS, "\n"
		"InterestRateVector___setslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j)\n"
		"InterestRateVector___setslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j, InterestRateVector v)\n"
		""},
	 { "InterestRateVector___delslice__", _wrap_InterestRateVector___delslice__, METH_VARARGS, "InterestRateVector___delslice__(InterestRateVector self, std::vector< InterestRate >::difference_type i, std::vector< InterestRate >::difference_type j)"},
	 { "InterestRateVector___delitem__", _wrap_InterestRateVector___delitem__, METH_VARARGS, "\n"
		"InterestRateVector___delitem__(InterestRateVector self, std::vector< InterestRate >::difference_type i)\n"
		"InterestRateVector___delitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "InterestRateVector___getitem__", _wrap_InterestRateVector___getitem__, METH_VARARGS, "\n"
		"InterestRateVector___getitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice) -> InterestRateVector\n"
		"InterestRateVector___getitem__(InterestRateVector self, std::vector< InterestRate >::difference_type i) -> InterestRate\n"
		""},
	 { "InterestRateVector___setitem__", _wrap_InterestRateVector___setitem__, METH_VARARGS, "\n"
		"InterestRateVector___setitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice, InterestRateVector v)\n"
		"InterestRateVector___setitem__(InterestRateVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"InterestRateVector___setitem__(InterestRateVector self, std::vector< InterestRate >::difference_type i, InterestRate x)\n"
		""},
	 { "InterestRateVector_pop", _wrap_InterestRateVector_pop, METH_O, "InterestRateVector_pop(InterestRateVector self) -> InterestRate"},
	 { "InterestRateVector_append", _wrap_InterestRateVector_append, METH_VARARGS, "InterestRateVector_append(InterestRateVector self, InterestRate x)"},
	 { "InterestRateVector_empty", _wrap_InterestRateVector_empty, METH_O, "InterestRateVector_empty(InterestRateVector self) -> bool"},
	 { "InterestRateVector_size", _wrap_InterestRateVector_size, METH_O, "InterestRateVector_size(InterestRateVector self) -> std::vector< InterestRate >::size_type"},
	 { "InterestRateVector_swap", _wrap_InterestRateVector_swap, METH_VARARGS, "InterestRateVector_swap(InterestRateVector self, InterestRateVector v)"},
	 { "InterestRateVector_begin", _wrap_InterestRateVector_begin, METH_O, "InterestRateVector_begin(InterestRateVector self) -> std::vector< InterestRate >::iterator"},
	 { "InterestRateVector_end", _wrap_InterestRateVector_end, METH_O, "InterestRateVector_end(InterestRateVector self) -> std::vector< InterestRate >::iterator"},
	 { "InterestRateVector_rbegin", _wrap_InterestRateVector_rbegin, METH_O, "InterestRateVector_rbegin(InterestRateVector self) -> std::vector< InterestRate >::reverse_iterator"},
	 { "InterestRateVector_rend", _wrap_InterestRateVector_rend, METH_O, "InterestRateVector_rend(InterestRateVector self) -> std::vector< InterestRate >::reverse_iterator"},
	 { "InterestRateVector_clear", _wrap_InterestRateVector_clear, METH_O, "InterestRateVector_clear(InterestRateVector self)"},
	 { "InterestRateVector_get_allocator", _wrap_InterestRateVector_get_allocator, METH_O, "InterestRateVector_get_allocator(InterestRateVector self) -> std::vector< InterestRate >::allocator_type"},
	 { "InterestRateVector_pop_back", _wrap_InterestRateVector_pop_back, METH_O, "InterestRateVector_pop_back(InterestRateVector self)"},
	 { "InterestRateVector_erase", _wrap_InterestRateVector_erase, METH_VARARGS, "\n"
		"InterestRateVector_erase(InterestRateVector self, std::vector< InterestRate >::iterator pos) -> std::vector< InterestRate >::iterator\n"
		"InterestRateVector_erase(InterestRateVector self, std::vector< InterestRate >::iterator first, std::vector< InterestRate >::iterator last) -> std::vector< InterestRate >::iterator\n"
		""},
	 { "new_InterestRateVector", _wrap_new_InterestRateVector, METH_VARARGS, "\n"
		"InterestRateVector()\n"
		"InterestRateVector(InterestRateVector other)\n"
		"InterestRateVector(std::vector< InterestRate >::size_type size)\n"
		"new_InterestRateVector(std::vector< InterestRate >::size_type size, InterestRate value) -> InterestRateVector\n"
		""},
	 { "InterestRateVector_push_back", _wrap_InterestRateVector_push_back, METH_VARARGS, "InterestRateVector_push_back(InterestRateVector self, InterestRate x)"},
	 { "InterestRateVector_front", _wrap_InterestRateVector_front, METH_O, "InterestRateVector_front(InterestRateVector self) -> InterestRate"},
	 { "InterestRateVector_back", _wrap_InterestRateVector_back, METH_O, "InterestRateVector_back(InterestRateVector self) -> InterestRate"},
	 { "InterestRateVector_assign", _wrap_InterestRateVector_assign, METH_VARARGS, "InterestRateVector_assign(InterestRateVector self, std::vector< InterestRate >::size_type n, InterestRate x)"},
	 { "InterestRateVector_resize", _wrap_InterestRateVector_resize, METH_VARARGS, "\n"
		"InterestRateVector_resize(InterestRateVector self, std::vector< InterestRate >::size_type new_size)\n"
		"InterestRateVector_resize(InterestRateVector self, std::vector< InterestRate >::size_type new_size, InterestRate x)\n"
		""},
	 { "InterestRateVector_insert", _wrap_InterestRateVector_insert, METH_VARARGS, "\n"
		"InterestRateVector_insert(InterestRateVector self, std::vector< InterestRate >::iterator pos, InterestRate x) -> std::vector< InterestRate >::iterator\n"
		"InterestRateVector_insert(InterestRateVector self, std::vector< InterestRate >::iterator pos, std::vector< InterestRate >::size_type n, InterestRate x)\n"
		""},
	 { "InterestRateVector_reserve", _wrap_InterestRateVector_reserve, METH_VARARGS, "InterestRateVector_reserve(InterestRateVector self, std::vector< InterestRate >::size_type n)"},
	 { "InterestRateVector_capacity", _wrap_InterestRateVector_capacity, METH_O, "InterestRateVector_capacity(InterestRateVector self) -> std::vector< InterestRate >::size_type"},
	 { "delete_InterestRateVector", _wrap_delete_InterestRateVector, METH_O, "delete_InterestRateVector(InterestRateVector self)"},
	 { "InterestRateVector_swigregister", InterestRateVector_swigregister, METH_O, NULL},
	 { "InterestRateVector_swiginit", InterestRateVector_swiginit, METH_VARARGS, NULL},
	 { "new_Observable", _wrap_new_Observable, METH_NOARGS, "new_Observable() -> Observable"},
	 { "delete_Observable", _wrap_delete_Observable, METH_O, "delete_Observable(Observable self)"},
	 { "Observable_swigregister", Observable_swigregister, METH_O, NULL},
	 { "Observable_swiginit", Observable_swiginit, METH_VARARGS, NULL},
	 { "new_Observer", _wrap_new_Observer, METH_O, "new_Observer(PyObject * callback) -> Observer"},
	 { "Observer__registerWith", _wrap_Observer__registerWith, METH_VARARGS, "Observer__registerWith(Observer self, ext::shared_ptr< Observable > const & arg2)"},
	 { "Observer__unregisterWith", _wrap_Observer__unregisterWith, METH_VARARGS, "Observer__unregisterWith(Observer self, ext::shared_ptr< Observable > const & arg2)"},
	 { "delete_Observer", _wrap_delete_Observer, METH_O, "delete_Observer(Observer self)"},
	 { "Observer_swigregister", Observer_swigregister, METH_O, NULL},
	 { "Observer_swiginit", Observer_swiginit, METH_VARARGS, NULL},
	 { "new_Array", _wrap_new_Array, METH_VARARGS, "\n"
		"Array()\n"
		"Array(Size n, Real fill=0.0)\n"
		"new_Array(Array arg1) -> Array\n"
		""},
	 { "Array___len__", _wrap_Array___len__, METH_O, "Array___len__(Array self) -> Size"},
	 { "Array___str__", _wrap_Array___str__, METH_O, "Array___str__(Array self) -> std::string"},
	 { "Array___add__", _wrap_Array___add__, METH_VARARGS, "Array___add__(Array self, Array a) -> Array"},
	 { "Array___sub__", _wrap_Array___sub__, METH_VARARGS, "Array___sub__(Array self, Array a) -> Array"},
	 { "Array___mul__", _wrap_Array___mul__, METH_VARARGS, "\n"
		"Array___mul__(Array self, Real a) -> Array\n"
		"Array___mul__(Array self, Array a) -> Real\n"
		"Array___mul__(Array self, Matrix a) -> Array\n"
		""},
	 { "Array___div__", _wrap_Array___div__, METH_VARARGS, "Array___div__(Array self, Real a) -> Array"},
	 { "Array___rmul__", _wrap_Array___rmul__, METH_VARARGS, "Array___rmul__(Array self, Real a) -> Array"},
	 { "Array___getslice__", _wrap_Array___getslice__, METH_VARARGS, "Array___getslice__(Array self, Integer i, Integer j) -> Array"},
	 { "Array___setslice__", _wrap_Array___setslice__, METH_VARARGS, "Array___setslice__(Array self, Integer i, Integer j, Array rhs)"},
	 { "Array___nonzero__", _wrap_Array___nonzero__, METH_O, "Array___nonzero__(Array self) -> bool"},
	 { "Array___bool__", _wrap_Array___bool__, METH_O, "Array___bool__(Array self) -> bool"},
	 { "Array___getitem__", _wrap_Array___getitem__, METH_VARARGS, "Array___getitem__(Array self, Integer i) -> Real"},
	 { "Array___setitem__", _wrap_Array___setitem__, METH_VARARGS, "Array___setitem__(Array self, Integer i, Real x)"},
	 { "delete_Array", _wrap_delete_Array, METH_O, "delete_Array(Array self)"},
	 { "Array_swigregister", Array_swigregister, METH_O, NULL},
	 { "Array_swiginit", Array_swiginit, METH_VARARGS, NULL},
	 { "MatrixRow___getitem__", _wrap_MatrixRow___getitem__, METH_VARARGS, "MatrixRow___getitem__(MatrixRow self, Integer i) -> Real"},
	 { "MatrixRow___setitem__", _wrap_MatrixRow___setitem__, METH_VARARGS, "MatrixRow___setitem__(MatrixRow self, Integer i, Real x)"},
	 { "delete_MatrixRow", _wrap_delete_MatrixRow, METH_O, "delete_MatrixRow(MatrixRow self)"},
	 { "MatrixRow_swigregister", MatrixRow_swigregister, METH_O, NULL},
	 { "new_Matrix", _wrap_new_Matrix, METH_VARARGS, "\n"
		"Matrix()\n"
		"Matrix(Size rows, Size columns, Real fill=0.0)\n"
		"new_Matrix(Matrix arg1) -> Matrix\n"
		""},
	 { "Matrix_rows", _wrap_Matrix_rows, METH_O, "Matrix_rows(Matrix self) -> Size"},
	 { "Matrix_columns", _wrap_Matrix_columns, METH_O, "Matrix_columns(Matrix self) -> Size"},
	 { "Matrix___str__", _wrap_Matrix___str__, METH_O, "Matrix___str__(Matrix self) -> std::string"},
	 { "Matrix___add__", _wrap_Matrix___add__, METH_VARARGS, "Matrix___add__(Matrix self, Matrix m) -> Matrix"},
	 { "Matrix___sub__", _wrap_Matrix___sub__, METH_VARARGS, "Matrix___sub__(Matrix self, Matrix m) -> Matrix"},
	 { "Matrix___mul__", _wrap_Matrix___mul__, METH_VARARGS, "\n"
		"Matrix___mul__(Matrix self, Real x) -> Matrix\n"
		"Matrix___mul__(Matrix self, Array x) -> Array\n"
		"Matrix___mul__(Matrix self, Matrix x) -> Matrix\n"
		""},
	 { "Matrix___div__", _wrap_Matrix___div__, METH_VARARGS, "Matrix___div__(Matrix self, Real x) -> Matrix"},
	 { "Matrix___getitem__", _wrap_Matrix___getitem__, METH_VARARGS, "Matrix___getitem__(Matrix self, Integer i) -> MatrixRow"},
	 { "Matrix___rmul__", _wrap_Matrix___rmul__, METH_VARARGS, "\n"
		"Matrix___rmul__(Matrix self, Real x) -> Matrix\n"
		"Matrix___rmul__(Matrix self, Array x) -> Array\n"
		"Matrix___rmul__(Matrix self, Matrix x) -> Matrix\n"
		""},
	 { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"},
	 { "Matrix_swigregister", Matrix_swigregister, METH_O, NULL},
	 { "Matrix_swiginit", Matrix_swiginit, METH_VARARGS, NULL},
	 { "new_SalvagingAlgorithm", _wrap_new_SalvagingAlgorithm, METH_NOARGS, "new_SalvagingAlgorithm() -> SalvagingAlgorithm"},
	 { "delete_SalvagingAlgorithm", _wrap_delete_SalvagingAlgorithm, METH_O, "delete_SalvagingAlgorithm(SalvagingAlgorithm self)"},
	 { "SalvagingAlgorithm_swigregister", SalvagingAlgorithm_swigregister, METH_O, NULL},
	 { "SalvagingAlgorithm_swiginit", SalvagingAlgorithm_swiginit, METH_VARARGS, NULL},
	 { "inverse", _wrap_inverse, METH_O, "inverse(Matrix m) -> Matrix"},
	 { "transpose", _wrap_transpose, METH_O, "transpose(Matrix m) -> Matrix"},
	 { "outerProduct", _wrap_outerProduct, METH_VARARGS, "outerProduct(Array v1, Array v2) -> Matrix"},
	 { "pseudoSqrt", _wrap_pseudoSqrt, METH_VARARGS, "pseudoSqrt(Matrix m, SalvagingAlgorithm::Type a) -> Matrix"},
	 { "new_SVD", _wrap_new_SVD, METH_O, "new_SVD(Matrix arg1) -> SVD"},
	 { "SVD_U", _wrap_SVD_U, METH_O, "SVD_U(SVD self) -> Matrix"},
	 { "SVD_V", _wrap_SVD_V, METH_O, "SVD_V(SVD self) -> Matrix"},
	 { "SVD_S", _wrap_SVD_S, METH_O, "SVD_S(SVD self) -> Matrix"},
	 { "SVD_singularValues", _wrap_SVD_singularValues, METH_O, "SVD_singularValues(SVD self) -> Array"},
	 { "delete_SVD", _wrap_delete_SVD, METH_O, "delete_SVD(SVD self)"},
	 { "SVD_swigregister", SVD_swigregister, METH_O, NULL},
	 { "SVD_swiginit", SVD_swiginit, METH_VARARGS, NULL},
	 { "new_MatrixMultiplicationProxy", _wrap_new_MatrixMultiplicationProxy, METH_O, "new_MatrixMultiplicationProxy(PyObject * matrixMult) -> MatrixMultiplicationProxy"},
	 { "MatrixMultiplicationProxy___call__", _wrap_MatrixMultiplicationProxy___call__, METH_VARARGS, "MatrixMultiplicationProxy___call__(MatrixMultiplicationProxy self, Array x) -> Array"},
	 { "delete_MatrixMultiplicationProxy", _wrap_delete_MatrixMultiplicationProxy, METH_O, "delete_MatrixMultiplicationProxy(MatrixMultiplicationProxy self)"},
	 { "MatrixMultiplicationProxy_swigregister", MatrixMultiplicationProxy_swigregister, METH_O, NULL},
	 { "MatrixMultiplicationProxy_swiginit", MatrixMultiplicationProxy_swiginit, METH_VARARGS, NULL},
	 { "BiCGstab_solve", _wrap_BiCGstab_solve, METH_VARARGS, "BiCGstab_solve(BiCGstab self, Array b, Array x0=Array()) -> Array"},
	 { "new_BiCGstab", _wrap_new_BiCGstab, METH_VARARGS, "\n"
		"BiCGstab(MatrixMultiplicationProxy proxy, Size maxIter, Real relTol)\n"
		"new_BiCGstab(MatrixMultiplicationProxy proxy, Size maxIter, Real relTol, MatrixMultiplicationProxy preconditioner) -> BiCGstab\n"
		""},
	 { "delete_BiCGstab", _wrap_delete_BiCGstab, METH_O, "delete_BiCGstab(BiCGstab self)"},
	 { "BiCGstab_swigregister", BiCGstab_swigregister, METH_O, NULL},
	 { "BiCGstab_swiginit", BiCGstab_swiginit, METH_VARARGS, NULL},
	 { "GMRES_solve", _wrap_GMRES_solve, METH_VARARGS, "GMRES_solve(GMRES self, Array b, Array x0=Array()) -> Array"},
	 { "GMRES_solveWithRestart", _wrap_GMRES_solveWithRestart, METH_VARARGS, "GMRES_solveWithRestart(GMRES self, Size restart, Array b, Array x0=Array()) -> Array"},
	 { "new_GMRES", _wrap_new_GMRES, METH_VARARGS, "\n"
		"GMRES(MatrixMultiplicationProxy proxy, Size maxIter, Real relTol)\n"
		"new_GMRES(MatrixMultiplicationProxy proxy, Size maxIter, Real relTol, MatrixMultiplicationProxy preconditioner) -> GMRES\n"
		""},
	 { "delete_GMRES", _wrap_delete_GMRES, METH_O, "delete_GMRES(GMRES self)"},
	 { "GMRES_swigregister", GMRES_swigregister, METH_O, NULL},
	 { "GMRES_swiginit", GMRES_swiginit, METH_VARARGS, NULL},
	 { "close", _wrap_close, METH_VARARGS, "\n"
		"close(Real x, Real y) -> bool\n"
		"close(Real x, Real y, Size n) -> bool\n"
		""},
	 { "close_enough", _wrap_close_enough, METH_VARARGS, "\n"
		"close_enough(Real x, Real y) -> bool\n"
		"close_enough(Real x, Real y, Size n) -> bool\n"
		""},
	 { "Quote_value", _wrap_Quote_value, METH_O, "Quote_value(Quote self) -> Real"},
	 { "Quote_isValid", _wrap_Quote_isValid, METH_O, "Quote_isValid(Quote self) -> bool"},
	 { "delete_Quote", _wrap_delete_Quote, METH_O, "delete_Quote(Quote self)"},
	 { "Quote_swigregister", Quote_swigregister, METH_O, NULL},
	 { "new_QuoteHandle", _wrap_new_QuoteHandle, METH_VARARGS, "QuoteHandle(ext::shared_ptr< Quote > const & arg1=ext::shared_ptr())"},
	 { "QuoteHandle___deref__", _wrap_QuoteHandle___deref__, METH_O, "QuoteHandle___deref__(QuoteHandle self) -> ext::shared_ptr< Quote >"},
	 { "QuoteHandle_currentLink", _wrap_QuoteHandle_currentLink, METH_O, "QuoteHandle_currentLink(QuoteHandle self) -> ext::shared_ptr< Quote >"},
	 { "QuoteHandle___nonzero__", _wrap_QuoteHandle___nonzero__, METH_O, "QuoteHandle___nonzero__(QuoteHandle self) -> bool"},
	 { "QuoteHandle___bool__", _wrap_QuoteHandle___bool__, METH_O, "QuoteHandle___bool__(QuoteHandle self) -> bool"},
	 { "QuoteHandle_asObservable", _wrap_QuoteHandle_asObservable, METH_O, "QuoteHandle_asObservable(QuoteHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_QuoteHandle", _wrap_delete_QuoteHandle, METH_O, "delete_QuoteHandle(QuoteHandle self)"},
	 { "QuoteHandle_value", _wrap_QuoteHandle_value, METH_O, "QuoteHandle_value(QuoteHandle self) -> Real"},
	 { "QuoteHandle_isValid", _wrap_QuoteHandle_isValid, METH_O, "QuoteHandle_isValid(QuoteHandle self) -> bool"},
	 { "QuoteHandle_swigregister", QuoteHandle_swigregister, METH_O, NULL},
	 { "QuoteHandle_swiginit", QuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableQuoteHandle", _wrap_new_RelinkableQuoteHandle, METH_VARARGS, "RelinkableQuoteHandle(ext::shared_ptr< Quote > const & arg1=ext::shared_ptr())"},
	 { "RelinkableQuoteHandle_linkTo", _wrap_RelinkableQuoteHandle_linkTo, METH_VARARGS, "RelinkableQuoteHandle_linkTo(RelinkableQuoteHandle self, ext::shared_ptr< Quote > const & arg2)"},
	 { "RelinkableQuoteHandle_reset", _wrap_RelinkableQuoteHandle_reset, METH_O, "RelinkableQuoteHandle_reset(RelinkableQuoteHandle self)"},
	 { "delete_RelinkableQuoteHandle", _wrap_delete_RelinkableQuoteHandle, METH_O, "delete_RelinkableQuoteHandle(RelinkableQuoteHandle self)"},
	 { "RelinkableQuoteHandle_swigregister", RelinkableQuoteHandle_swigregister, METH_O, NULL},
	 { "RelinkableQuoteHandle_swiginit", RelinkableQuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleQuote", _wrap_new_SimpleQuote, METH_O, "new_SimpleQuote(Real value) -> SimpleQuote"},
	 { "SimpleQuote_setValue", _wrap_SimpleQuote_setValue, METH_VARARGS, "SimpleQuote_setValue(SimpleQuote self, Real value)"},
	 { "delete_SimpleQuote", _wrap_delete_SimpleQuote, METH_O, "delete_SimpleQuote(SimpleQuote self)"},
	 { "SimpleQuote_swigregister", SimpleQuote_swigregister, METH_O, NULL},
	 { "SimpleQuote_swiginit", SimpleQuote_swiginit, METH_VARARGS, NULL},
	 { "new_LastFixingQuote", _wrap_new_LastFixingQuote, METH_O, "new_LastFixingQuote(ext::shared_ptr< Index > index) -> LastFixingQuote"},
	 { "LastFixingQuote_index", _wrap_LastFixingQuote_index, METH_O, "LastFixingQuote_index(LastFixingQuote self) -> ext::shared_ptr< Index >"},
	 { "LastFixingQuote_referenceDate", _wrap_LastFixingQuote_referenceDate, METH_O, "LastFixingQuote_referenceDate(LastFixingQuote self) -> Date"},
	 { "delete_LastFixingQuote", _wrap_delete_LastFixingQuote, METH_O, "delete_LastFixingQuote(LastFixingQuote self)"},
	 { "LastFixingQuote_swigregister", LastFixingQuote_swigregister, METH_O, NULL},
	 { "LastFixingQuote_swiginit", LastFixingQuote_swiginit, METH_VARARGS, NULL},
	 { "new_DerivedQuote", _wrap_new_DerivedQuote, METH_VARARGS, "new_DerivedQuote(QuoteHandle h, PyObject * function) -> DerivedQuote"},
	 { "delete_DerivedQuote", _wrap_delete_DerivedQuote, METH_O, "delete_DerivedQuote(DerivedQuote self)"},
	 { "DerivedQuote_swigregister", DerivedQuote_swigregister, METH_O, NULL},
	 { "DerivedQuote_swiginit", DerivedQuote_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeQuote", _wrap_new_CompositeQuote, METH_VARARGS, "new_CompositeQuote(QuoteHandle h1, QuoteHandle h2, PyObject * function) -> CompositeQuote"},
	 { "delete_CompositeQuote", _wrap_delete_CompositeQuote, METH_O, "delete_CompositeQuote(CompositeQuote self)"},
	 { "CompositeQuote_swigregister", CompositeQuote_swigregister, METH_O, NULL},
	 { "CompositeQuote_swiginit", CompositeQuote_swiginit, METH_VARARGS, NULL},
	 { "QuoteVector_iterator", _wrap_QuoteVector_iterator, METH_O, "QuoteVector_iterator(QuoteVector self) -> SwigPyIterator"},
	 { "QuoteVector___nonzero__", _wrap_QuoteVector___nonzero__, METH_O, "QuoteVector___nonzero__(QuoteVector self) -> bool"},
	 { "QuoteVector___bool__", _wrap_QuoteVector___bool__, METH_O, "QuoteVector___bool__(QuoteVector self) -> bool"},
	 { "QuoteVector___len__", _wrap_QuoteVector___len__, METH_O, "QuoteVector___len__(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::size_type"},
	 { "QuoteVector___getslice__", _wrap_QuoteVector___getslice__, METH_VARARGS, "QuoteVector___getslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j) -> QuoteVector"},
	 { "QuoteVector___setslice__", _wrap_QuoteVector___setslice__, METH_VARARGS, "\n"
		"QuoteVector___setslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j)\n"
		"QuoteVector___setslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j, QuoteVector v)\n"
		""},
	 { "QuoteVector___delslice__", _wrap_QuoteVector___delslice__, METH_VARARGS, "QuoteVector___delslice__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::difference_type j)"},
	 { "QuoteVector___delitem__", _wrap_QuoteVector___delitem__, METH_VARARGS, "\n"
		"QuoteVector___delitem__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i)\n"
		"QuoteVector___delitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "QuoteVector___getitem__", _wrap_QuoteVector___getitem__, METH_VARARGS, "\n"
		"QuoteVector___getitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteVector\n"
		"QuoteVector___getitem__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i) -> std::vector< ext::shared_ptr< Quote > >::value_type const &\n"
		""},
	 { "QuoteVector___setitem__", _wrap_QuoteVector___setitem__, METH_VARARGS, "\n"
		"QuoteVector___setitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice, QuoteVector v)\n"
		"QuoteVector___setitem__(QuoteVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"QuoteVector___setitem__(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::difference_type i, std::vector< ext::shared_ptr< Quote > >::value_type const & x)\n"
		""},
	 { "QuoteVector_pop", _wrap_QuoteVector_pop, METH_O, "QuoteVector_pop(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::value_type"},
	 { "QuoteVector_append", _wrap_QuoteVector_append, METH_VARARGS, "QuoteVector_append(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::value_type const & x)"},
	 { "QuoteVector_empty", _wrap_QuoteVector_empty, METH_O, "QuoteVector_empty(QuoteVector self) -> bool"},
	 { "QuoteVector_size", _wrap_QuoteVector_size, METH_O, "QuoteVector_size(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::size_type"},
	 { "QuoteVector_swap", _wrap_QuoteVector_swap, METH_VARARGS, "QuoteVector_swap(QuoteVector self, QuoteVector v)"},
	 { "QuoteVector_begin", _wrap_QuoteVector_begin, METH_O, "QuoteVector_begin(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::iterator"},
	 { "QuoteVector_end", _wrap_QuoteVector_end, METH_O, "QuoteVector_end(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::iterator"},
	 { "QuoteVector_rbegin", _wrap_QuoteVector_rbegin, METH_O, "QuoteVector_rbegin(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::reverse_iterator"},
	 { "QuoteVector_rend", _wrap_QuoteVector_rend, METH_O, "QuoteVector_rend(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::reverse_iterator"},
	 { "QuoteVector_clear", _wrap_QuoteVector_clear, METH_O, "QuoteVector_clear(QuoteVector self)"},
	 { "QuoteVector_get_allocator", _wrap_QuoteVector_get_allocator, METH_O, "QuoteVector_get_allocator(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::allocator_type"},
	 { "QuoteVector_pop_back", _wrap_QuoteVector_pop_back, METH_O, "QuoteVector_pop_back(QuoteVector self)"},
	 { "QuoteVector_erase", _wrap_QuoteVector_erase, METH_VARARGS, "\n"
		"QuoteVector_erase(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator pos) -> std::vector< ext::shared_ptr< Quote > >::iterator\n"
		"QuoteVector_erase(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator first, std::vector< ext::shared_ptr< Quote > >::iterator last) -> std::vector< ext::shared_ptr< Quote > >::iterator\n"
		""},
	 { "new_QuoteVector", _wrap_new_QuoteVector, METH_VARARGS, "\n"
		"QuoteVector()\n"
		"QuoteVector(QuoteVector other)\n"
		"QuoteVector(std::vector< ext::shared_ptr< Quote > >::size_type size)\n"
		"new_QuoteVector(std::vector< ext::shared_ptr< Quote > >::size_type size, std::vector< ext::shared_ptr< Quote > >::value_type const & value) -> QuoteVector\n"
		""},
	 { "QuoteVector_push_back", _wrap_QuoteVector_push_back, METH_VARARGS, "QuoteVector_push_back(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::value_type const & x)"},
	 { "QuoteVector_front", _wrap_QuoteVector_front, METH_O, "QuoteVector_front(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::value_type const &"},
	 { "QuoteVector_back", _wrap_QuoteVector_back, METH_O, "QuoteVector_back(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::value_type const &"},
	 { "QuoteVector_assign", _wrap_QuoteVector_assign, METH_VARARGS, "QuoteVector_assign(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type n, std::vector< ext::shared_ptr< Quote > >::value_type const & x)"},
	 { "QuoteVector_resize", _wrap_QuoteVector_resize, METH_VARARGS, "\n"
		"QuoteVector_resize(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type new_size)\n"
		"QuoteVector_resize(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type new_size, std::vector< ext::shared_ptr< Quote > >::value_type const & x)\n"
		""},
	 { "QuoteVector_insert", _wrap_QuoteVector_insert, METH_VARARGS, "\n"
		"QuoteVector_insert(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator pos, std::vector< ext::shared_ptr< Quote > >::value_type const & x) -> std::vector< ext::shared_ptr< Quote > >::iterator\n"
		"QuoteVector_insert(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::iterator pos, std::vector< ext::shared_ptr< Quote > >::size_type n, std::vector< ext::shared_ptr< Quote > >::value_type const & x)\n"
		""},
	 { "QuoteVector_reserve", _wrap_QuoteVector_reserve, METH_VARARGS, "QuoteVector_reserve(QuoteVector self, std::vector< ext::shared_ptr< Quote > >::size_type n)"},
	 { "QuoteVector_capacity", _wrap_QuoteVector_capacity, METH_O, "QuoteVector_capacity(QuoteVector self) -> std::vector< ext::shared_ptr< Quote > >::size_type"},
	 { "delete_QuoteVector", _wrap_delete_QuoteVector, METH_O, "delete_QuoteVector(QuoteVector self)"},
	 { "QuoteVector_swigregister", QuoteVector_swigregister, METH_O, NULL},
	 { "QuoteVector_swiginit", QuoteVector_swiginit, METH_VARARGS, NULL},
	 { "QuoteVectorVector_iterator", _wrap_QuoteVectorVector_iterator, METH_O, "QuoteVectorVector_iterator(QuoteVectorVector self) -> SwigPyIterator"},
	 { "QuoteVectorVector___nonzero__", _wrap_QuoteVectorVector___nonzero__, METH_O, "QuoteVectorVector___nonzero__(QuoteVectorVector self) -> bool"},
	 { "QuoteVectorVector___bool__", _wrap_QuoteVectorVector___bool__, METH_O, "QuoteVectorVector___bool__(QuoteVectorVector self) -> bool"},
	 { "QuoteVectorVector___len__", _wrap_QuoteVectorVector___len__, METH_O, "QuoteVectorVector___len__(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type"},
	 { "QuoteVectorVector___getslice__", _wrap_QuoteVectorVector___getslice__, METH_VARARGS, "QuoteVectorVector___getslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j) -> QuoteVectorVector"},
	 { "QuoteVectorVector___setslice__", _wrap_QuoteVectorVector___setslice__, METH_VARARGS, "\n"
		"QuoteVectorVector___setslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j)\n"
		"QuoteVectorVector___setslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j, QuoteVectorVector v)\n"
		""},
	 { "QuoteVectorVector___delslice__", _wrap_QuoteVectorVector___delslice__, METH_VARARGS, "QuoteVectorVector___delslice__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type j)"},
	 { "QuoteVectorVector___delitem__", _wrap_QuoteVectorVector___delitem__, METH_VARARGS, "\n"
		"QuoteVectorVector___delitem__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i)\n"
		"QuoteVectorVector___delitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "QuoteVectorVector___getitem__", _wrap_QuoteVectorVector___getitem__, METH_VARARGS, "\n"
		"QuoteVectorVector___getitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteVectorVector\n"
		"QuoteVectorVector___getitem__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i) -> QuoteVector\n"
		""},
	 { "QuoteVectorVector___setitem__", _wrap_QuoteVectorVector___setitem__, METH_VARARGS, "\n"
		"QuoteVectorVector___setitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice, QuoteVectorVector v)\n"
		"QuoteVectorVector___setitem__(QuoteVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"QuoteVectorVector___setitem__(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::difference_type i, QuoteVector x)\n"
		""},
	 { "QuoteVectorVector_pop", _wrap_QuoteVectorVector_pop, METH_O, "QuoteVectorVector_pop(QuoteVectorVector self) -> QuoteVector"},
	 { "QuoteVectorVector_append", _wrap_QuoteVectorVector_append, METH_VARARGS, "QuoteVectorVector_append(QuoteVectorVector self, QuoteVector x)"},
	 { "QuoteVectorVector_empty", _wrap_QuoteVectorVector_empty, METH_O, "QuoteVectorVector_empty(QuoteVectorVector self) -> bool"},
	 { "QuoteVectorVector_size", _wrap_QuoteVectorVector_size, METH_O, "QuoteVectorVector_size(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type"},
	 { "QuoteVectorVector_swap", _wrap_QuoteVectorVector_swap, METH_VARARGS, "QuoteVectorVector_swap(QuoteVectorVector self, QuoteVectorVector v)"},
	 { "QuoteVectorVector_begin", _wrap_QuoteVectorVector_begin, METH_O, "QuoteVectorVector_begin(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator"},
	 { "QuoteVectorVector_end", _wrap_QuoteVectorVector_end, METH_O, "QuoteVectorVector_end(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator"},
	 { "QuoteVectorVector_rbegin", _wrap_QuoteVectorVector_rbegin, METH_O, "QuoteVectorVector_rbegin(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator"},
	 { "QuoteVectorVector_rend", _wrap_QuoteVectorVector_rend, METH_O, "QuoteVectorVector_rend(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::reverse_iterator"},
	 { "QuoteVectorVector_clear", _wrap_QuoteVectorVector_clear, METH_O, "QuoteVectorVector_clear(QuoteVectorVector self)"},
	 { "QuoteVectorVector_get_allocator", _wrap_QuoteVectorVector_get_allocator, METH_O, "QuoteVectorVector_get_allocator(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::allocator_type"},
	 { "QuoteVectorVector_pop_back", _wrap_QuoteVectorVector_pop_back, METH_O, "QuoteVectorVector_pop_back(QuoteVectorVector self)"},
	 { "QuoteVectorVector_erase", _wrap_QuoteVectorVector_erase, METH_VARARGS, "\n"
		"QuoteVectorVector_erase(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator\n"
		"QuoteVectorVector_erase(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator first, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator last) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator\n"
		""},
	 { "new_QuoteVectorVector", _wrap_new_QuoteVectorVector, METH_VARARGS, "\n"
		"QuoteVectorVector()\n"
		"QuoteVectorVector(QuoteVectorVector other)\n"
		"QuoteVectorVector(std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type size)\n"
		"new_QuoteVectorVector(std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type size, QuoteVector value) -> QuoteVectorVector\n"
		""},
	 { "QuoteVectorVector_push_back", _wrap_QuoteVectorVector_push_back, METH_VARARGS, "QuoteVectorVector_push_back(QuoteVectorVector self, QuoteVector x)"},
	 { "QuoteVectorVector_front", _wrap_QuoteVectorVector_front, METH_O, "QuoteVectorVector_front(QuoteVectorVector self) -> QuoteVector"},
	 { "QuoteVectorVector_back", _wrap_QuoteVectorVector_back, METH_O, "QuoteVectorVector_back(QuoteVectorVector self) -> QuoteVector"},
	 { "QuoteVectorVector_assign", _wrap_QuoteVectorVector_assign, METH_VARARGS, "QuoteVectorVector_assign(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n, QuoteVector x)"},
	 { "QuoteVectorVector_resize", _wrap_QuoteVectorVector_resize, METH_VARARGS, "\n"
		"QuoteVectorVector_resize(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type new_size)\n"
		"QuoteVectorVector_resize(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type new_size, QuoteVector x)\n"
		""},
	 { "QuoteVectorVector_insert", _wrap_QuoteVectorVector_insert, METH_VARARGS, "\n"
		"QuoteVectorVector_insert(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos, QuoteVector x) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator\n"
		"QuoteVectorVector_insert(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::iterator pos, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n, QuoteVector x)\n"
		""},
	 { "QuoteVectorVector_reserve", _wrap_QuoteVectorVector_reserve, METH_VARARGS, "QuoteVectorVector_reserve(QuoteVectorVector self, std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type n)"},
	 { "QuoteVectorVector_capacity", _wrap_QuoteVectorVector_capacity, METH_O, "QuoteVectorVector_capacity(QuoteVectorVector self) -> std::vector< std::vector< ext::shared_ptr< Quote > > >::size_type"},
	 { "delete_QuoteVectorVector", _wrap_delete_QuoteVectorVector, METH_O, "delete_QuoteVectorVector(QuoteVectorVector self)"},
	 { "QuoteVectorVector_swigregister", QuoteVectorVector_swigregister, METH_O, NULL},
	 { "QuoteVectorVector_swiginit", QuoteVectorVector_swiginit, METH_VARARGS, NULL},
	 { "QuoteHandleVector_iterator", _wrap_QuoteHandleVector_iterator, METH_O, "QuoteHandleVector_iterator(QuoteHandleVector self) -> SwigPyIterator"},
	 { "QuoteHandleVector___nonzero__", _wrap_QuoteHandleVector___nonzero__, METH_O, "QuoteHandleVector___nonzero__(QuoteHandleVector self) -> bool"},
	 { "QuoteHandleVector___bool__", _wrap_QuoteHandleVector___bool__, METH_O, "QuoteHandleVector___bool__(QuoteHandleVector self) -> bool"},
	 { "QuoteHandleVector___len__", _wrap_QuoteHandleVector___len__, METH_O, "QuoteHandleVector___len__(QuoteHandleVector self) -> std::vector< Handle< Quote > >::size_type"},
	 { "QuoteHandleVector___getslice__", _wrap_QuoteHandleVector___getslice__, METH_VARARGS, "QuoteHandleVector___getslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j) -> QuoteHandleVector"},
	 { "QuoteHandleVector___setslice__", _wrap_QuoteHandleVector___setslice__, METH_VARARGS, "\n"
		"QuoteHandleVector___setslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j)\n"
		"QuoteHandleVector___setslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j, QuoteHandleVector v)\n"
		""},
	 { "QuoteHandleVector___delslice__", _wrap_QuoteHandleVector___delslice__, METH_VARARGS, "QuoteHandleVector___delslice__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, std::vector< Handle< Quote > >::difference_type j)"},
	 { "QuoteHandleVector___delitem__", _wrap_QuoteHandleVector___delitem__, METH_VARARGS, "\n"
		"QuoteHandleVector___delitem__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i)\n"
		"QuoteHandleVector___delitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "QuoteHandleVector___getitem__", _wrap_QuoteHandleVector___getitem__, METH_VARARGS, "\n"
		"QuoteHandleVector___getitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteHandleVector\n"
		"QuoteHandleVector___getitem__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i) -> QuoteHandle\n"
		""},
	 { "QuoteHandleVector___setitem__", _wrap_QuoteHandleVector___setitem__, METH_VARARGS, "\n"
		"QuoteHandleVector___setitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice, QuoteHandleVector v)\n"
		"QuoteHandleVector___setitem__(QuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"QuoteHandleVector___setitem__(QuoteHandleVector self, std::vector< Handle< Quote > >::difference_type i, QuoteHandle x)\n"
		""},
	 { "QuoteHandleVector_pop", _wrap_QuoteHandleVector_pop, METH_O, "QuoteHandleVector_pop(QuoteHandleVector self) -> QuoteHandle"},
	 { "QuoteHandleVector_append", _wrap_QuoteHandleVector_append, METH_VARARGS, "QuoteHandleVector_append(QuoteHandleVector self, QuoteHandle x)"},
	 { "QuoteHandleVector_empty", _wrap_QuoteHandleVector_empty, METH_O, "QuoteHandleVector_empty(QuoteHandleVector self) -> bool"},
	 { "QuoteHandleVector_size", _wrap_QuoteHandleVector_size, METH_O, "QuoteHandleVector_size(QuoteHandleVector self) -> std::vector< Handle< Quote > >::size_type"},
	 { "QuoteHandleVector_swap", _wrap_QuoteHandleVector_swap, METH_VARARGS, "QuoteHandleVector_swap(QuoteHandleVector self, QuoteHandleVector v)"},
	 { "QuoteHandleVector_begin", _wrap_QuoteHandleVector_begin, METH_O, "QuoteHandleVector_begin(QuoteHandleVector self) -> std::vector< Handle< Quote > >::iterator"},
	 { "QuoteHandleVector_end", _wrap_QuoteHandleVector_end, METH_O, "QuoteHandleVector_end(QuoteHandleVector self) -> std::vector< Handle< Quote > >::iterator"},
	 { "QuoteHandleVector_rbegin", _wrap_QuoteHandleVector_rbegin, METH_O, "QuoteHandleVector_rbegin(QuoteHandleVector self) -> std::vector< Handle< Quote > >::reverse_iterator"},
	 { "QuoteHandleVector_rend", _wrap_QuoteHandleVector_rend, METH_O, "QuoteHandleVector_rend(QuoteHandleVector self) -> std::vector< Handle< Quote > >::reverse_iterator"},
	 { "QuoteHandleVector_clear", _wrap_QuoteHandleVector_clear, METH_O, "QuoteHandleVector_clear(QuoteHandleVector self)"},
	 { "QuoteHandleVector_get_allocator", _wrap_QuoteHandleVector_get_allocator, METH_O, "QuoteHandleVector_get_allocator(QuoteHandleVector self) -> std::vector< Handle< Quote > >::allocator_type"},
	 { "QuoteHandleVector_pop_back", _wrap_QuoteHandleVector_pop_back, METH_O, "QuoteHandleVector_pop_back(QuoteHandleVector self)"},
	 { "QuoteHandleVector_erase", _wrap_QuoteHandleVector_erase, METH_VARARGS, "\n"
		"QuoteHandleVector_erase(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator pos) -> std::vector< Handle< Quote > >::iterator\n"
		"QuoteHandleVector_erase(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator first, std::vector< Handle< Quote > >::iterator last) -> std::vector< Handle< Quote > >::iterator\n"
		""},
	 { "new_QuoteHandleVector", _wrap_new_QuoteHandleVector, METH_VARARGS, "\n"
		"QuoteHandleVector()\n"
		"QuoteHandleVector(QuoteHandleVector other)\n"
		"QuoteHandleVector(std::vector< Handle< Quote > >::size_type size)\n"
		"new_QuoteHandleVector(std::vector< Handle< Quote > >::size_type size, QuoteHandle value) -> QuoteHandleVector\n"
		""},
	 { "QuoteHandleVector_push_back", _wrap_QuoteHandleVector_push_back, METH_VARARGS, "QuoteHandleVector_push_back(QuoteHandleVector self, QuoteHandle x)"},
	 { "QuoteHandleVector_front", _wrap_QuoteHandleVector_front, METH_O, "QuoteHandleVector_front(QuoteHandleVector self) -> QuoteHandle"},
	 { "QuoteHandleVector_back", _wrap_QuoteHandleVector_back, METH_O, "QuoteHandleVector_back(QuoteHandleVector self) -> QuoteHandle"},
	 { "QuoteHandleVector_assign", _wrap_QuoteHandleVector_assign, METH_VARARGS, "QuoteHandleVector_assign(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type n, QuoteHandle x)"},
	 { "QuoteHandleVector_resize", _wrap_QuoteHandleVector_resize, METH_VARARGS, "\n"
		"QuoteHandleVector_resize(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type new_size)\n"
		"QuoteHandleVector_resize(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type new_size, QuoteHandle x)\n"
		""},
	 { "QuoteHandleVector_insert", _wrap_QuoteHandleVector_insert, METH_VARARGS, "\n"
		"QuoteHandleVector_insert(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator pos, QuoteHandle x) -> std::vector< Handle< Quote > >::iterator\n"
		"QuoteHandleVector_insert(QuoteHandleVector self, std::vector< Handle< Quote > >::iterator pos, std::vector< Handle< Quote > >::size_type n, QuoteHandle x)\n"
		""},
	 { "QuoteHandleVector_reserve", _wrap_QuoteHandleVector_reserve, METH_VARARGS, "QuoteHandleVector_reserve(QuoteHandleVector self, std::vector< Handle< Quote > >::size_type n)"},
	 { "QuoteHandleVector_capacity", _wrap_QuoteHandleVector_capacity, METH_O, "QuoteHandleVector_capacity(QuoteHandleVector self) -> std::vector< Handle< Quote > >::size_type"},
	 { "delete_QuoteHandleVector", _wrap_delete_QuoteHandleVector, METH_O, "delete_QuoteHandleVector(QuoteHandleVector self)"},
	 { "QuoteHandleVector_swigregister", QuoteHandleVector_swigregister, METH_O, NULL},
	 { "QuoteHandleVector_swiginit", QuoteHandleVector_swiginit, METH_VARARGS, NULL},
	 { "QuoteHandleVectorVector_iterator", _wrap_QuoteHandleVectorVector_iterator, METH_O, "QuoteHandleVectorVector_iterator(QuoteHandleVectorVector self) -> SwigPyIterator"},
	 { "QuoteHandleVectorVector___nonzero__", _wrap_QuoteHandleVectorVector___nonzero__, METH_O, "QuoteHandleVectorVector___nonzero__(QuoteHandleVectorVector self) -> bool"},
	 { "QuoteHandleVectorVector___bool__", _wrap_QuoteHandleVectorVector___bool__, METH_O, "QuoteHandleVectorVector___bool__(QuoteHandleVectorVector self) -> bool"},
	 { "QuoteHandleVectorVector___len__", _wrap_QuoteHandleVectorVector___len__, METH_O, "QuoteHandleVectorVector___len__(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::size_type"},
	 { "QuoteHandleVectorVector___getslice__", _wrap_QuoteHandleVectorVector___getslice__, METH_VARARGS, "QuoteHandleVectorVector___getslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j) -> QuoteHandleVectorVector"},
	 { "QuoteHandleVectorVector___setslice__", _wrap_QuoteHandleVectorVector___setslice__, METH_VARARGS, "\n"
		"QuoteHandleVectorVector___setslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j)\n"
		"QuoteHandleVectorVector___setslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j, QuoteHandleVectorVector v)\n"
		""},
	 { "QuoteHandleVectorVector___delslice__", _wrap_QuoteHandleVectorVector___delslice__, METH_VARARGS, "QuoteHandleVectorVector___delslice__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, std::vector< std::vector< Handle< Quote > > >::difference_type j)"},
	 { "QuoteHandleVectorVector___delitem__", _wrap_QuoteHandleVectorVector___delitem__, METH_VARARGS, "\n"
		"QuoteHandleVectorVector___delitem__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i)\n"
		"QuoteHandleVectorVector___delitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "QuoteHandleVectorVector___getitem__", _wrap_QuoteHandleVectorVector___getitem__, METH_VARARGS, "\n"
		"QuoteHandleVectorVector___getitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice) -> QuoteHandleVectorVector\n"
		"QuoteHandleVectorVector___getitem__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i) -> QuoteHandleVector\n"
		""},
	 { "QuoteHandleVectorVector___setitem__", _wrap_QuoteHandleVectorVector___setitem__, METH_VARARGS, "\n"
		"QuoteHandleVectorVector___setitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice, QuoteHandleVectorVector v)\n"
		"QuoteHandleVectorVector___setitem__(QuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"QuoteHandleVectorVector___setitem__(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::difference_type i, QuoteHandleVector x)\n"
		""},
	 { "QuoteHandleVectorVector_pop", _wrap_QuoteHandleVectorVector_pop, METH_O, "QuoteHandleVectorVector_pop(QuoteHandleVectorVector self) -> QuoteHandleVector"},
	 { "QuoteHandleVectorVector_append", _wrap_QuoteHandleVectorVector_append, METH_VARARGS, "QuoteHandleVectorVector_append(QuoteHandleVectorVector self, QuoteHandleVector x)"},
	 { "QuoteHandleVectorVector_empty", _wrap_QuoteHandleVectorVector_empty, METH_O, "QuoteHandleVectorVector_empty(QuoteHandleVectorVector self) -> bool"},
	 { "QuoteHandleVectorVector_size", _wrap_QuoteHandleVectorVector_size, METH_O, "QuoteHandleVectorVector_size(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::size_type"},
	 { "QuoteHandleVectorVector_swap", _wrap_QuoteHandleVectorVector_swap, METH_VARARGS, "QuoteHandleVectorVector_swap(QuoteHandleVectorVector self, QuoteHandleVectorVector v)"},
	 { "QuoteHandleVectorVector_begin", _wrap_QuoteHandleVectorVector_begin, METH_O, "QuoteHandleVectorVector_begin(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::iterator"},
	 { "QuoteHandleVectorVector_end", _wrap_QuoteHandleVectorVector_end, METH_O, "QuoteHandleVectorVector_end(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::iterator"},
	 { "QuoteHandleVectorVector_rbegin", _wrap_QuoteHandleVectorVector_rbegin, METH_O, "QuoteHandleVectorVector_rbegin(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::reverse_iterator"},
	 { "QuoteHandleVectorVector_rend", _wrap_QuoteHandleVectorVector_rend, METH_O, "QuoteHandleVectorVector_rend(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::reverse_iterator"},
	 { "QuoteHandleVectorVector_clear", _wrap_QuoteHandleVectorVector_clear, METH_O, "QuoteHandleVectorVector_clear(QuoteHandleVectorVector self)"},
	 { "QuoteHandleVectorVector_get_allocator", _wrap_QuoteHandleVectorVector_get_allocator, METH_O, "QuoteHandleVectorVector_get_allocator(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::allocator_type"},
	 { "QuoteHandleVectorVector_pop_back", _wrap_QuoteHandleVectorVector_pop_back, METH_O, "QuoteHandleVectorVector_pop_back(QuoteHandleVectorVector self)"},
	 { "QuoteHandleVectorVector_erase", _wrap_QuoteHandleVectorVector_erase, METH_VARARGS, "\n"
		"QuoteHandleVectorVector_erase(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator pos) -> std::vector< std::vector< Handle< Quote > > >::iterator\n"
		"QuoteHandleVectorVector_erase(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator first, std::vector< std::vector< Handle< Quote > > >::iterator last) -> std::vector< std::vector< Handle< Quote > > >::iterator\n"
		""},
	 { "new_QuoteHandleVectorVector", _wrap_new_QuoteHandleVectorVector, METH_VARARGS, "\n"
		"QuoteHandleVectorVector()\n"
		"QuoteHandleVectorVector(QuoteHandleVectorVector other)\n"
		"QuoteHandleVectorVector(std::vector< std::vector< Handle< Quote > > >::size_type size)\n"
		"new_QuoteHandleVectorVector(std::vector< std::vector< Handle< Quote > > >::size_type size, QuoteHandleVector value) -> QuoteHandleVectorVector\n"
		""},
	 { "QuoteHandleVectorVector_push_back", _wrap_QuoteHandleVectorVector_push_back, METH_VARARGS, "QuoteHandleVectorVector_push_back(QuoteHandleVectorVector self, QuoteHandleVector x)"},
	 { "QuoteHandleVectorVector_front", _wrap_QuoteHandleVectorVector_front, METH_O, "QuoteHandleVectorVector_front(QuoteHandleVectorVector self) -> QuoteHandleVector"},
	 { "QuoteHandleVectorVector_back", _wrap_QuoteHandleVectorVector_back, METH_O, "QuoteHandleVectorVector_back(QuoteHandleVectorVector self) -> QuoteHandleVector"},
	 { "QuoteHandleVectorVector_assign", _wrap_QuoteHandleVectorVector_assign, METH_VARARGS, "QuoteHandleVectorVector_assign(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type n, QuoteHandleVector x)"},
	 { "QuoteHandleVectorVector_resize", _wrap_QuoteHandleVectorVector_resize, METH_VARARGS, "\n"
		"QuoteHandleVectorVector_resize(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type new_size)\n"
		"QuoteHandleVectorVector_resize(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type new_size, QuoteHandleVector x)\n"
		""},
	 { "QuoteHandleVectorVector_insert", _wrap_QuoteHandleVectorVector_insert, METH_VARARGS, "\n"
		"QuoteHandleVectorVector_insert(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator pos, QuoteHandleVector x) -> std::vector< std::vector< Handle< Quote > > >::iterator\n"
		"QuoteHandleVectorVector_insert(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::iterator pos, std::vector< std::vector< Handle< Quote > > >::size_type n, QuoteHandleVector x)\n"
		""},
	 { "QuoteHandleVectorVector_reserve", _wrap_QuoteHandleVectorVector_reserve, METH_VARARGS, "QuoteHandleVectorVector_reserve(QuoteHandleVectorVector self, std::vector< std::vector< Handle< Quote > > >::size_type n)"},
	 { "QuoteHandleVectorVector_capacity", _wrap_QuoteHandleVectorVector_capacity, METH_O, "QuoteHandleVectorVector_capacity(QuoteHandleVectorVector self) -> std::vector< std::vector< Handle< Quote > > >::size_type"},
	 { "delete_QuoteHandleVectorVector", _wrap_delete_QuoteHandleVectorVector, METH_O, "delete_QuoteHandleVectorVector(QuoteHandleVectorVector self)"},
	 { "QuoteHandleVectorVector_swigregister", QuoteHandleVectorVector_swigregister, METH_O, NULL},
	 { "QuoteHandleVectorVector_swiginit", QuoteHandleVectorVector_swiginit, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVector_iterator", _wrap_RelinkableQuoteHandleVector_iterator, METH_O, "RelinkableQuoteHandleVector_iterator(RelinkableQuoteHandleVector self) -> SwigPyIterator"},
	 { "RelinkableQuoteHandleVector___nonzero__", _wrap_RelinkableQuoteHandleVector___nonzero__, METH_O, "RelinkableQuoteHandleVector___nonzero__(RelinkableQuoteHandleVector self) -> bool"},
	 { "RelinkableQuoteHandleVector___bool__", _wrap_RelinkableQuoteHandleVector___bool__, METH_O, "RelinkableQuoteHandleVector___bool__(RelinkableQuoteHandleVector self) -> bool"},
	 { "RelinkableQuoteHandleVector___len__", _wrap_RelinkableQuoteHandleVector___len__, METH_O, "RelinkableQuoteHandleVector___len__(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::size_type"},
	 { "RelinkableQuoteHandleVector___getslice__", _wrap_RelinkableQuoteHandleVector___getslice__, METH_VARARGS, "RelinkableQuoteHandleVector___getslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j) -> RelinkableQuoteHandleVector"},
	 { "RelinkableQuoteHandleVector___setslice__", _wrap_RelinkableQuoteHandleVector___setslice__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector___setslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j)\n"
		"RelinkableQuoteHandleVector___setslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j, RelinkableQuoteHandleVector v)\n"
		""},
	 { "RelinkableQuoteHandleVector___delslice__", _wrap_RelinkableQuoteHandleVector___delslice__, METH_VARARGS, "RelinkableQuoteHandleVector___delslice__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, std::vector< RelinkableHandle< Quote > >::difference_type j)"},
	 { "RelinkableQuoteHandleVector___delitem__", _wrap_RelinkableQuoteHandleVector___delitem__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector___delitem__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i)\n"
		"RelinkableQuoteHandleVector___delitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "RelinkableQuoteHandleVector___getitem__", _wrap_RelinkableQuoteHandleVector___getitem__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector___getitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice) -> RelinkableQuoteHandleVector\n"
		"RelinkableQuoteHandleVector___getitem__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i) -> RelinkableQuoteHandle\n"
		""},
	 { "RelinkableQuoteHandleVector___setitem__", _wrap_RelinkableQuoteHandleVector___setitem__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector___setitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice, RelinkableQuoteHandleVector v)\n"
		"RelinkableQuoteHandleVector___setitem__(RelinkableQuoteHandleVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"RelinkableQuoteHandleVector___setitem__(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::difference_type i, RelinkableQuoteHandle x)\n"
		""},
	 { "RelinkableQuoteHandleVector_pop", _wrap_RelinkableQuoteHandleVector_pop, METH_O, "RelinkableQuoteHandleVector_pop(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandle"},
	 { "RelinkableQuoteHandleVector_append", _wrap_RelinkableQuoteHandleVector_append, METH_VARARGS, "RelinkableQuoteHandleVector_append(RelinkableQuoteHandleVector self, RelinkableQuoteHandle x)"},
	 { "RelinkableQuoteHandleVector_empty", _wrap_RelinkableQuoteHandleVector_empty, METH_O, "RelinkableQuoteHandleVector_empty(RelinkableQuoteHandleVector self) -> bool"},
	 { "RelinkableQuoteHandleVector_size", _wrap_RelinkableQuoteHandleVector_size, METH_O, "RelinkableQuoteHandleVector_size(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::size_type"},
	 { "RelinkableQuoteHandleVector_swap", _wrap_RelinkableQuoteHandleVector_swap, METH_VARARGS, "RelinkableQuoteHandleVector_swap(RelinkableQuoteHandleVector self, RelinkableQuoteHandleVector v)"},
	 { "RelinkableQuoteHandleVector_begin", _wrap_RelinkableQuoteHandleVector_begin, METH_O, "RelinkableQuoteHandleVector_begin(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::iterator"},
	 { "RelinkableQuoteHandleVector_end", _wrap_RelinkableQuoteHandleVector_end, METH_O, "RelinkableQuoteHandleVector_end(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::iterator"},
	 { "RelinkableQuoteHandleVector_rbegin", _wrap_RelinkableQuoteHandleVector_rbegin, METH_O, "RelinkableQuoteHandleVector_rbegin(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::reverse_iterator"},
	 { "RelinkableQuoteHandleVector_rend", _wrap_RelinkableQuoteHandleVector_rend, METH_O, "RelinkableQuoteHandleVector_rend(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::reverse_iterator"},
	 { "RelinkableQuoteHandleVector_clear", _wrap_RelinkableQuoteHandleVector_clear, METH_O, "RelinkableQuoteHandleVector_clear(RelinkableQuoteHandleVector self)"},
	 { "RelinkableQuoteHandleVector_get_allocator", _wrap_RelinkableQuoteHandleVector_get_allocator, METH_O, "RelinkableQuoteHandleVector_get_allocator(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::allocator_type"},
	 { "RelinkableQuoteHandleVector_pop_back", _wrap_RelinkableQuoteHandleVector_pop_back, METH_O, "RelinkableQuoteHandleVector_pop_back(RelinkableQuoteHandleVector self)"},
	 { "RelinkableQuoteHandleVector_erase", _wrap_RelinkableQuoteHandleVector_erase, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector_erase(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator pos) -> std::vector< RelinkableHandle< Quote > >::iterator\n"
		"RelinkableQuoteHandleVector_erase(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator first, std::vector< RelinkableHandle< Quote > >::iterator last) -> std::vector< RelinkableHandle< Quote > >::iterator\n"
		""},
	 { "new_RelinkableQuoteHandleVector", _wrap_new_RelinkableQuoteHandleVector, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector()\n"
		"RelinkableQuoteHandleVector(RelinkableQuoteHandleVector other)\n"
		"RelinkableQuoteHandleVector(std::vector< RelinkableHandle< Quote > >::size_type size)\n"
		"new_RelinkableQuoteHandleVector(std::vector< RelinkableHandle< Quote > >::size_type size, RelinkableQuoteHandle value) -> RelinkableQuoteHandleVector\n"
		""},
	 { "RelinkableQuoteHandleVector_push_back", _wrap_RelinkableQuoteHandleVector_push_back, METH_VARARGS, "RelinkableQuoteHandleVector_push_back(RelinkableQuoteHandleVector self, RelinkableQuoteHandle x)"},
	 { "RelinkableQuoteHandleVector_front", _wrap_RelinkableQuoteHandleVector_front, METH_O, "RelinkableQuoteHandleVector_front(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandle"},
	 { "RelinkableQuoteHandleVector_back", _wrap_RelinkableQuoteHandleVector_back, METH_O, "RelinkableQuoteHandleVector_back(RelinkableQuoteHandleVector self) -> RelinkableQuoteHandle"},
	 { "RelinkableQuoteHandleVector_assign", _wrap_RelinkableQuoteHandleVector_assign, METH_VARARGS, "RelinkableQuoteHandleVector_assign(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type n, RelinkableQuoteHandle x)"},
	 { "RelinkableQuoteHandleVector_resize", _wrap_RelinkableQuoteHandleVector_resize, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector_resize(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type new_size)\n"
		"RelinkableQuoteHandleVector_resize(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type new_size, RelinkableQuoteHandle x)\n"
		""},
	 { "RelinkableQuoteHandleVector_insert", _wrap_RelinkableQuoteHandleVector_insert, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVector_insert(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator pos, RelinkableQuoteHandle x) -> std::vector< RelinkableHandle< Quote > >::iterator\n"
		"RelinkableQuoteHandleVector_insert(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::iterator pos, std::vector< RelinkableHandle< Quote > >::size_type n, RelinkableQuoteHandle x)\n"
		""},
	 { "RelinkableQuoteHandleVector_reserve", _wrap_RelinkableQuoteHandleVector_reserve, METH_VARARGS, "RelinkableQuoteHandleVector_reserve(RelinkableQuoteHandleVector self, std::vector< RelinkableHandle< Quote > >::size_type n)"},
	 { "RelinkableQuoteHandleVector_capacity", _wrap_RelinkableQuoteHandleVector_capacity, METH_O, "RelinkableQuoteHandleVector_capacity(RelinkableQuoteHandleVector self) -> std::vector< RelinkableHandle< Quote > >::size_type"},
	 { "delete_RelinkableQuoteHandleVector", _wrap_delete_RelinkableQuoteHandleVector, METH_O, "delete_RelinkableQuoteHandleVector(RelinkableQuoteHandleVector self)"},
	 { "RelinkableQuoteHandleVector_swigregister", RelinkableQuoteHandleVector_swigregister, METH_O, NULL},
	 { "RelinkableQuoteHandleVector_swiginit", RelinkableQuoteHandleVector_swiginit, METH_VARARGS, NULL},
	 { "RelinkableQuoteHandleVectorVector_iterator", _wrap_RelinkableQuoteHandleVectorVector_iterator, METH_O, "RelinkableQuoteHandleVectorVector_iterator(RelinkableQuoteHandleVectorVector self) -> SwigPyIterator"},
	 { "RelinkableQuoteHandleVectorVector___nonzero__", _wrap_RelinkableQuoteHandleVectorVector___nonzero__, METH_O, "RelinkableQuoteHandleVectorVector___nonzero__(RelinkableQuoteHandleVectorVector self) -> bool"},
	 { "RelinkableQuoteHandleVectorVector___bool__", _wrap_RelinkableQuoteHandleVectorVector___bool__, METH_O, "RelinkableQuoteHandleVectorVector___bool__(RelinkableQuoteHandleVectorVector self) -> bool"},
	 { "RelinkableQuoteHandleVectorVector___len__", _wrap_RelinkableQuoteHandleVectorVector___len__, METH_O, "RelinkableQuoteHandleVectorVector___len__(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::size_type"},
	 { "RelinkableQuoteHandleVectorVector___getslice__", _wrap_RelinkableQuoteHandleVectorVector___getslice__, METH_VARARGS, "RelinkableQuoteHandleVectorVector___getslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j) -> RelinkableQuoteHandleVectorVector"},
	 { "RelinkableQuoteHandleVectorVector___setslice__", _wrap_RelinkableQuoteHandleVectorVector___setslice__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector___setslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j)\n"
		"RelinkableQuoteHandleVectorVector___setslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j, RelinkableQuoteHandleVectorVector v)\n"
		""},
	 { "RelinkableQuoteHandleVectorVector___delslice__", _wrap_RelinkableQuoteHandleVectorVector___delslice__, METH_VARARGS, "RelinkableQuoteHandleVectorVector___delslice__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type j)"},
	 { "RelinkableQuoteHandleVectorVector___delitem__", _wrap_RelinkableQuoteHandleVectorVector___delitem__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector___delitem__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i)\n"
		"RelinkableQuoteHandleVectorVector___delitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "RelinkableQuoteHandleVectorVector___getitem__", _wrap_RelinkableQuoteHandleVectorVector___getitem__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector___getitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice) -> RelinkableQuoteHandleVectorVector\n"
		"RelinkableQuoteHandleVectorVector___getitem__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i) -> RelinkableQuoteHandleVector\n"
		""},
	 { "RelinkableQuoteHandleVectorVector___setitem__", _wrap_RelinkableQuoteHandleVectorVector___setitem__, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector___setitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice, RelinkableQuoteHandleVectorVector v)\n"
		"RelinkableQuoteHandleVectorVector___setitem__(RelinkableQuoteHandleVectorVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"RelinkableQuoteHandleVectorVector___setitem__(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::difference_type i, RelinkableQuoteHandleVector x)\n"
		""},
	 { "RelinkableQuoteHandleVectorVector_pop", _wrap_RelinkableQuoteHandleVectorVector_pop, METH_O, "RelinkableQuoteHandleVectorVector_pop(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVector"},
	 { "RelinkableQuoteHandleVectorVector_append", _wrap_RelinkableQuoteHandleVectorVector_append, METH_VARARGS, "RelinkableQuoteHandleVectorVector_append(RelinkableQuoteHandleVectorVector self, RelinkableQuoteHandleVector x)"},
	 { "RelinkableQuoteHandleVectorVector_empty", _wrap_RelinkableQuoteHandleVectorVector_empty, METH_O, "RelinkableQuoteHandleVectorVector_empty(RelinkableQuoteHandleVectorVector self) -> bool"},
	 { "RelinkableQuoteHandleVectorVector_size", _wrap_RelinkableQuoteHandleVectorVector_size, METH_O, "RelinkableQuoteHandleVectorVector_size(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::size_type"},
	 { "RelinkableQuoteHandleVectorVector_swap", _wrap_RelinkableQuoteHandleVectorVector_swap, METH_VARARGS, "RelinkableQuoteHandleVectorVector_swap(RelinkableQuoteHandleVectorVector self, RelinkableQuoteHandleVectorVector v)"},
	 { "RelinkableQuoteHandleVectorVector_begin", _wrap_RelinkableQuoteHandleVectorVector_begin, METH_O, "RelinkableQuoteHandleVectorVector_begin(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator"},
	 { "RelinkableQuoteHandleVectorVector_end", _wrap_RelinkableQuoteHandleVectorVector_end, METH_O, "RelinkableQuoteHandleVectorVector_end(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator"},
	 { "RelinkableQuoteHandleVectorVector_rbegin", _wrap_RelinkableQuoteHandleVectorVector_rbegin, METH_O, "RelinkableQuoteHandleVectorVector_rbegin(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator"},
	 { "RelinkableQuoteHandleVectorVector_rend", _wrap_RelinkableQuoteHandleVectorVector_rend, METH_O, "RelinkableQuoteHandleVectorVector_rend(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::reverse_iterator"},
	 { "RelinkableQuoteHandleVectorVector_clear", _wrap_RelinkableQuoteHandleVectorVector_clear, METH_O, "RelinkableQuoteHandleVectorVector_clear(RelinkableQuoteHandleVectorVector self)"},
	 { "RelinkableQuoteHandleVectorVector_get_allocator", _wrap_RelinkableQuoteHandleVectorVector_get_allocator, METH_O, "RelinkableQuoteHandleVectorVector_get_allocator(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::allocator_type"},
	 { "RelinkableQuoteHandleVectorVector_pop_back", _wrap_RelinkableQuoteHandleVectorVector_pop_back, METH_O, "RelinkableQuoteHandleVectorVector_pop_back(RelinkableQuoteHandleVectorVector self)"},
	 { "RelinkableQuoteHandleVectorVector_erase", _wrap_RelinkableQuoteHandleVectorVector_erase, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector_erase(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator\n"
		"RelinkableQuoteHandleVectorVector_erase(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator first, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator last) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator\n"
		""},
	 { "new_RelinkableQuoteHandleVectorVector", _wrap_new_RelinkableQuoteHandleVectorVector, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector()\n"
		"RelinkableQuoteHandleVectorVector(RelinkableQuoteHandleVectorVector other)\n"
		"RelinkableQuoteHandleVectorVector(std::vector< std::vector< RelinkableHandle< Quote > > >::size_type size)\n"
		"new_RelinkableQuoteHandleVectorVector(std::vector< std::vector< RelinkableHandle< Quote > > >::size_type size, RelinkableQuoteHandleVector value) -> RelinkableQuoteHandleVectorVector\n"
		""},
	 { "RelinkableQuoteHandleVectorVector_push_back", _wrap_RelinkableQuoteHandleVectorVector_push_back, METH_VARARGS, "RelinkableQuoteHandleVectorVector_push_back(RelinkableQuoteHandleVectorVector self, RelinkableQuoteHandleVector x)"},
	 { "RelinkableQuoteHandleVectorVector_front", _wrap_RelinkableQuoteHandleVectorVector_front, METH_O, "RelinkableQuoteHandleVectorVector_front(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVector"},
	 { "RelinkableQuoteHandleVectorVector_back", _wrap_RelinkableQuoteHandleVectorVector_back, METH_O, "RelinkableQuoteHandleVectorVector_back(RelinkableQuoteHandleVectorVector self) -> RelinkableQuoteHandleVector"},
	 { "RelinkableQuoteHandleVectorVector_assign", _wrap_RelinkableQuoteHandleVectorVector_assign, METH_VARARGS, "RelinkableQuoteHandleVectorVector_assign(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n, RelinkableQuoteHandleVector x)"},
	 { "RelinkableQuoteHandleVectorVector_resize", _wrap_RelinkableQuoteHandleVectorVector_resize, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector_resize(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type new_size)\n"
		"RelinkableQuoteHandleVectorVector_resize(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type new_size, RelinkableQuoteHandleVector x)\n"
		""},
	 { "RelinkableQuoteHandleVectorVector_insert", _wrap_RelinkableQuoteHandleVectorVector_insert, METH_VARARGS, "\n"
		"RelinkableQuoteHandleVectorVector_insert(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos, RelinkableQuoteHandleVector x) -> std::vector< std::vector< RelinkableHandle< Quote > > >::iterator\n"
		"RelinkableQuoteHandleVectorVector_insert(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::iterator pos, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n, RelinkableQuoteHandleVector x)\n"
		""},
	 { "RelinkableQuoteHandleVectorVector_reserve", _wrap_RelinkableQuoteHandleVectorVector_reserve, METH_VARARGS, "RelinkableQuoteHandleVectorVector_reserve(RelinkableQuoteHandleVectorVector self, std::vector< std::vector< RelinkableHandle< Quote > > >::size_type n)"},
	 { "RelinkableQuoteHandleVectorVector_capacity", _wrap_RelinkableQuoteHandleVectorVector_capacity, METH_O, "RelinkableQuoteHandleVectorVector_capacity(RelinkableQuoteHandleVectorVector self) -> std::vector< std::vector< RelinkableHandle< Quote > > >::size_type"},
	 { "delete_RelinkableQuoteHandleVectorVector", _wrap_delete_RelinkableQuoteHandleVectorVector, METH_O, "delete_RelinkableQuoteHandleVectorVector(RelinkableQuoteHandleVectorVector self)"},
	 { "RelinkableQuoteHandleVectorVector_swigregister", RelinkableQuoteHandleVectorVector_swigregister, METH_O, NULL},
	 { "RelinkableQuoteHandleVectorVector_swiginit", RelinkableQuoteHandleVectorVector_swiginit, METH_VARARGS, NULL},
	 { "Brent_setMaxEvaluations", _wrap_Brent_setMaxEvaluations, METH_VARARGS, "Brent_setMaxEvaluations(Brent self, Size evaluations)"},
	 { "Brent_setLowerBound", _wrap_Brent_setLowerBound, METH_VARARGS, "Brent_setLowerBound(Brent self, Real lowerBound)"},
	 { "Brent_setUpperBound", _wrap_Brent_setUpperBound, METH_VARARGS, "Brent_setUpperBound(Brent self, Real upperBound)"},
	 { "Brent_solve", _wrap_Brent_solve, METH_VARARGS, "\n"
		"Brent_solve(Brent self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"Brent_solve(Brent self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_Brent", _wrap_new_Brent, METH_NOARGS, "new_Brent() -> Brent"},
	 { "delete_Brent", _wrap_delete_Brent, METH_O, "delete_Brent(Brent self)"},
	 { "Brent_swigregister", Brent_swigregister, METH_O, NULL},
	 { "Brent_swiginit", Brent_swiginit, METH_VARARGS, NULL},
	 { "Bisection_setMaxEvaluations", _wrap_Bisection_setMaxEvaluations, METH_VARARGS, "Bisection_setMaxEvaluations(Bisection self, Size evaluations)"},
	 { "Bisection_setLowerBound", _wrap_Bisection_setLowerBound, METH_VARARGS, "Bisection_setLowerBound(Bisection self, Real lowerBound)"},
	 { "Bisection_setUpperBound", _wrap_Bisection_setUpperBound, METH_VARARGS, "Bisection_setUpperBound(Bisection self, Real upperBound)"},
	 { "Bisection_solve", _wrap_Bisection_solve, METH_VARARGS, "\n"
		"Bisection_solve(Bisection self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"Bisection_solve(Bisection self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_Bisection", _wrap_new_Bisection, METH_NOARGS, "new_Bisection() -> Bisection"},
	 { "delete_Bisection", _wrap_delete_Bisection, METH_O, "delete_Bisection(Bisection self)"},
	 { "Bisection_swigregister", Bisection_swigregister, METH_O, NULL},
	 { "Bisection_swiginit", Bisection_swiginit, METH_VARARGS, NULL},
	 { "FalsePosition_setMaxEvaluations", _wrap_FalsePosition_setMaxEvaluations, METH_VARARGS, "FalsePosition_setMaxEvaluations(FalsePosition self, Size evaluations)"},
	 { "FalsePosition_setLowerBound", _wrap_FalsePosition_setLowerBound, METH_VARARGS, "FalsePosition_setLowerBound(FalsePosition self, Real lowerBound)"},
	 { "FalsePosition_setUpperBound", _wrap_FalsePosition_setUpperBound, METH_VARARGS, "FalsePosition_setUpperBound(FalsePosition self, Real upperBound)"},
	 { "FalsePosition_solve", _wrap_FalsePosition_solve, METH_VARARGS, "\n"
		"FalsePosition_solve(FalsePosition self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"FalsePosition_solve(FalsePosition self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_FalsePosition", _wrap_new_FalsePosition, METH_NOARGS, "new_FalsePosition() -> FalsePosition"},
	 { "delete_FalsePosition", _wrap_delete_FalsePosition, METH_O, "delete_FalsePosition(FalsePosition self)"},
	 { "FalsePosition_swigregister", FalsePosition_swigregister, METH_O, NULL},
	 { "FalsePosition_swiginit", FalsePosition_swiginit, METH_VARARGS, NULL},
	 { "Ridder_setMaxEvaluations", _wrap_Ridder_setMaxEvaluations, METH_VARARGS, "Ridder_setMaxEvaluations(Ridder self, Size evaluations)"},
	 { "Ridder_setLowerBound", _wrap_Ridder_setLowerBound, METH_VARARGS, "Ridder_setLowerBound(Ridder self, Real lowerBound)"},
	 { "Ridder_setUpperBound", _wrap_Ridder_setUpperBound, METH_VARARGS, "Ridder_setUpperBound(Ridder self, Real upperBound)"},
	 { "Ridder_solve", _wrap_Ridder_solve, METH_VARARGS, "\n"
		"Ridder_solve(Ridder self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"Ridder_solve(Ridder self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_Ridder", _wrap_new_Ridder, METH_NOARGS, "new_Ridder() -> Ridder"},
	 { "delete_Ridder", _wrap_delete_Ridder, METH_O, "delete_Ridder(Ridder self)"},
	 { "Ridder_swigregister", Ridder_swigregister, METH_O, NULL},
	 { "Ridder_swiginit", Ridder_swiginit, METH_VARARGS, NULL},
	 { "Secant_setMaxEvaluations", _wrap_Secant_setMaxEvaluations, METH_VARARGS, "Secant_setMaxEvaluations(Secant self, Size evaluations)"},
	 { "Secant_setLowerBound", _wrap_Secant_setLowerBound, METH_VARARGS, "Secant_setLowerBound(Secant self, Real lowerBound)"},
	 { "Secant_setUpperBound", _wrap_Secant_setUpperBound, METH_VARARGS, "Secant_setUpperBound(Secant self, Real upperBound)"},
	 { "Secant_solve", _wrap_Secant_solve, METH_VARARGS, "\n"
		"Secant_solve(Secant self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"Secant_solve(Secant self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_Secant", _wrap_new_Secant, METH_NOARGS, "new_Secant() -> Secant"},
	 { "delete_Secant", _wrap_delete_Secant, METH_O, "delete_Secant(Secant self)"},
	 { "Secant_swigregister", Secant_swigregister, METH_O, NULL},
	 { "Secant_swiginit", Secant_swiginit, METH_VARARGS, NULL},
	 { "Newton_setMaxEvaluations", _wrap_Newton_setMaxEvaluations, METH_VARARGS, "Newton_setMaxEvaluations(Newton self, Size evaluations)"},
	 { "Newton_setLowerBound", _wrap_Newton_setLowerBound, METH_VARARGS, "Newton_setLowerBound(Newton self, Real lowerBound)"},
	 { "Newton_setUpperBound", _wrap_Newton_setUpperBound, METH_VARARGS, "Newton_setUpperBound(Newton self, Real upperBound)"},
	 { "Newton_solve", _wrap_Newton_solve, METH_VARARGS, "\n"
		"Newton_solve(Newton self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"Newton_solve(Newton self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_Newton", _wrap_new_Newton, METH_NOARGS, "new_Newton() -> Newton"},
	 { "delete_Newton", _wrap_delete_Newton, METH_O, "delete_Newton(Newton self)"},
	 { "Newton_swigregister", Newton_swigregister, METH_O, NULL},
	 { "Newton_swiginit", Newton_swiginit, METH_VARARGS, NULL},
	 { "NewtonSafe_setMaxEvaluations", _wrap_NewtonSafe_setMaxEvaluations, METH_VARARGS, "NewtonSafe_setMaxEvaluations(NewtonSafe self, Size evaluations)"},
	 { "NewtonSafe_setLowerBound", _wrap_NewtonSafe_setLowerBound, METH_VARARGS, "NewtonSafe_setLowerBound(NewtonSafe self, Real lowerBound)"},
	 { "NewtonSafe_setUpperBound", _wrap_NewtonSafe_setUpperBound, METH_VARARGS, "NewtonSafe_setUpperBound(NewtonSafe self, Real upperBound)"},
	 { "NewtonSafe_solve", _wrap_NewtonSafe_solve, METH_VARARGS, "\n"
		"NewtonSafe_solve(NewtonSafe self, PyObject * function, Real xAccuracy, Real guess, Real step) -> Real\n"
		"NewtonSafe_solve(NewtonSafe self, PyObject * function, Real xAccuracy, Real guess, Real xMin, Real xMax) -> Real\n"
		""},
	 { "new_NewtonSafe", _wrap_new_NewtonSafe, METH_NOARGS, "new_NewtonSafe() -> NewtonSafe"},
	 { "delete_NewtonSafe", _wrap_delete_NewtonSafe, METH_O, "delete_NewtonSafe(NewtonSafe self)"},
	 { "NewtonSafe_swigregister", NewtonSafe_swigregister, METH_O, NULL},
	 { "NewtonSafe_swiginit", NewtonSafe_swiginit, METH_VARARGS, NULL},
	 { "delete_Constraint", _wrap_delete_Constraint, METH_O, "delete_Constraint(Constraint self)"},
	 { "Constraint_swigregister", Constraint_swigregister, METH_O, NULL},
	 { "new_BoundaryConstraint", _wrap_new_BoundaryConstraint, METH_VARARGS, "new_BoundaryConstraint(Real lower, Real upper) -> BoundaryConstraint"},
	 { "delete_BoundaryConstraint", _wrap_delete_BoundaryConstraint, METH_O, "delete_BoundaryConstraint(BoundaryConstraint self)"},
	 { "BoundaryConstraint_swigregister", BoundaryConstraint_swigregister, METH_O, NULL},
	 { "BoundaryConstraint_swiginit", BoundaryConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_NoConstraint", _wrap_new_NoConstraint, METH_NOARGS, "new_NoConstraint() -> NoConstraint"},
	 { "delete_NoConstraint", _wrap_delete_NoConstraint, METH_O, "delete_NoConstraint(NoConstraint self)"},
	 { "NoConstraint_swigregister", NoConstraint_swigregister, METH_O, NULL},
	 { "NoConstraint_swiginit", NoConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_PositiveConstraint", _wrap_new_PositiveConstraint, METH_NOARGS, "new_PositiveConstraint() -> PositiveConstraint"},
	 { "delete_PositiveConstraint", _wrap_delete_PositiveConstraint, METH_O, "delete_PositiveConstraint(PositiveConstraint self)"},
	 { "PositiveConstraint_swigregister", PositiveConstraint_swigregister, METH_O, NULL},
	 { "PositiveConstraint_swiginit", PositiveConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeConstraint", _wrap_new_CompositeConstraint, METH_VARARGS, "new_CompositeConstraint(Constraint c1, Constraint c2) -> CompositeConstraint"},
	 { "delete_CompositeConstraint", _wrap_delete_CompositeConstraint, METH_O, "delete_CompositeConstraint(CompositeConstraint self)"},
	 { "CompositeConstraint_swigregister", CompositeConstraint_swigregister, METH_O, NULL},
	 { "CompositeConstraint_swiginit", CompositeConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_NonhomogeneousBoundaryConstraint", _wrap_new_NonhomogeneousBoundaryConstraint, METH_VARARGS, "new_NonhomogeneousBoundaryConstraint(Array l, Array u) -> NonhomogeneousBoundaryConstraint"},
	 { "delete_NonhomogeneousBoundaryConstraint", _wrap_delete_NonhomogeneousBoundaryConstraint, METH_O, "delete_NonhomogeneousBoundaryConstraint(NonhomogeneousBoundaryConstraint self)"},
	 { "NonhomogeneousBoundaryConstraint_swigregister", NonhomogeneousBoundaryConstraint_swigregister, METH_O, NULL},
	 { "NonhomogeneousBoundaryConstraint_swiginit", NonhomogeneousBoundaryConstraint_swiginit, METH_VARARGS, NULL},
	 { "new_EndCriteria", _wrap_new_EndCriteria, METH_VARARGS, "new_EndCriteria(Size maxIteration, Size maxStationaryStateIterations, Real rootEpsilon, Real functionEpsilon, Real gradientNormEpsilon) -> EndCriteria"},
	 { "EndCriteria___call__", _wrap_EndCriteria___call__, METH_VARARGS, "EndCriteria___call__(EndCriteria self, Size iteration, Size & statState, bool const positiveOptimization, Real const fold, Real const normgold, Real const fnew, Real const normgnewx, EndCriteria::Type & ecType) -> bool"},
	 { "delete_EndCriteria", _wrap_delete_EndCriteria, METH_O, "delete_EndCriteria(EndCriteria self)"},
	 { "EndCriteria_swigregister", EndCriteria_swigregister, METH_O, NULL},
	 { "EndCriteria_swiginit", EndCriteria_swiginit, METH_VARARGS, NULL},
	 { "delete_OptimizationMethod", _wrap_delete_OptimizationMethod, METH_O, "delete_OptimizationMethod(OptimizationMethod self)"},
	 { "OptimizationMethod_swigregister", OptimizationMethod_swigregister, METH_O, NULL},
	 { "new_ConjugateGradient", _wrap_new_ConjugateGradient, METH_NOARGS, "new_ConjugateGradient() -> ConjugateGradient"},
	 { "delete_ConjugateGradient", _wrap_delete_ConjugateGradient, METH_O, "delete_ConjugateGradient(ConjugateGradient self)"},
	 { "ConjugateGradient_swigregister", ConjugateGradient_swigregister, METH_O, NULL},
	 { "ConjugateGradient_swiginit", ConjugateGradient_swiginit, METH_VARARGS, NULL},
	 { "new_Simplex", _wrap_new_Simplex, METH_O, "new_Simplex(Real lambda_parameter) -> Simplex"},
	 { "Simplex_getLambda", _wrap_Simplex_getLambda, METH_O, "Simplex_getLambda(Simplex self) -> Real"},
	 { "delete_Simplex", _wrap_delete_Simplex, METH_O, "delete_Simplex(Simplex self)"},
	 { "Simplex_swigregister", Simplex_swigregister, METH_O, NULL},
	 { "Simplex_swiginit", Simplex_swiginit, METH_VARARGS, NULL},
	 { "new_SteepestDescent", _wrap_new_SteepestDescent, METH_NOARGS, "new_SteepestDescent() -> SteepestDescent"},
	 { "delete_SteepestDescent", _wrap_delete_SteepestDescent, METH_O, "delete_SteepestDescent(SteepestDescent self)"},
	 { "SteepestDescent_swigregister", SteepestDescent_swigregister, METH_O, NULL},
	 { "SteepestDescent_swiginit", SteepestDescent_swiginit, METH_VARARGS, NULL},
	 { "new_BFGS", _wrap_new_BFGS, METH_NOARGS, "new_BFGS() -> BFGS"},
	 { "delete_BFGS", _wrap_delete_BFGS, METH_O, "delete_BFGS(BFGS self)"},
	 { "BFGS_swigregister", BFGS_swigregister, METH_O, NULL},
	 { "BFGS_swiginit", BFGS_swiginit, METH_VARARGS, NULL},
	 { "new_LevenbergMarquardt", _wrap_new_LevenbergMarquardt, METH_VARARGS, "LevenbergMarquardt(Real epsfcn=1.0e-8, Real xtol=1.0e-8, Real gtol=1.0e-8, bool useCostFunctionsJacobian=False)"},
	 { "delete_LevenbergMarquardt", _wrap_delete_LevenbergMarquardt, METH_O, "delete_LevenbergMarquardt(LevenbergMarquardt self)"},
	 { "LevenbergMarquardt_swigregister", LevenbergMarquardt_swigregister, METH_O, NULL},
	 { "LevenbergMarquardt_swiginit", LevenbergMarquardt_swiginit, METH_VARARGS, NULL},
	 { "new_DifferentialEvolution", _wrap_new_DifferentialEvolution, METH_NOARGS, "new_DifferentialEvolution() -> DifferentialEvolution"},
	 { "delete_DifferentialEvolution", _wrap_delete_DifferentialEvolution, METH_O, "delete_DifferentialEvolution(DifferentialEvolution self)"},
	 { "DifferentialEvolution_swigregister", DifferentialEvolution_swigregister, METH_O, NULL},
	 { "DifferentialEvolution_swiginit", DifferentialEvolution_swiginit, METH_VARARGS, NULL},
	 { "new_SamplerGaussian", _wrap_new_SamplerGaussian, METH_VARARGS, "SamplerGaussian(unsigned long seed=0)"},
	 { "delete_SamplerGaussian", _wrap_delete_SamplerGaussian, METH_O, "delete_SamplerGaussian(SamplerGaussian self)"},
	 { "SamplerGaussian_swigregister", SamplerGaussian_swigregister, METH_O, NULL},
	 { "SamplerGaussian_swiginit", SamplerGaussian_swiginit, METH_VARARGS, NULL},
	 { "new_SamplerLogNormal", _wrap_new_SamplerLogNormal, METH_VARARGS, "SamplerLogNormal(unsigned long seed=0)"},
	 { "delete_SamplerLogNormal", _wrap_delete_SamplerLogNormal, METH_O, "delete_SamplerLogNormal(SamplerLogNormal self)"},
	 { "SamplerLogNormal_swigregister", SamplerLogNormal_swigregister, METH_O, NULL},
	 { "SamplerLogNormal_swiginit", SamplerLogNormal_swiginit, METH_VARARGS, NULL},
	 { "new_SamplerMirrorGaussian", _wrap_new_SamplerMirrorGaussian, METH_VARARGS, "SamplerMirrorGaussian(Array lower, Array upper, unsigned long seed=0)"},
	 { "delete_SamplerMirrorGaussian", _wrap_delete_SamplerMirrorGaussian, METH_O, "delete_SamplerMirrorGaussian(SamplerMirrorGaussian self)"},
	 { "SamplerMirrorGaussian_swigregister", SamplerMirrorGaussian_swigregister, METH_O, NULL},
	 { "SamplerMirrorGaussian_swiginit", SamplerMirrorGaussian_swiginit, METH_VARARGS, NULL},
	 { "new_ProbabilityBoltzmannDownhill", _wrap_new_ProbabilityBoltzmannDownhill, METH_VARARGS, "ProbabilityBoltzmannDownhill(unsigned long seed=0)"},
	 { "delete_ProbabilityBoltzmannDownhill", _wrap_delete_ProbabilityBoltzmannDownhill, METH_O, "delete_ProbabilityBoltzmannDownhill(ProbabilityBoltzmannDownhill self)"},
	 { "ProbabilityBoltzmannDownhill_swigregister", ProbabilityBoltzmannDownhill_swigregister, METH_O, NULL},
	 { "ProbabilityBoltzmannDownhill_swiginit", ProbabilityBoltzmannDownhill_swiginit, METH_VARARGS, NULL},
	 { "new_TemperatureExponential", _wrap_new_TemperatureExponential, METH_VARARGS, "TemperatureExponential(Real initialTemp, Size dimension, Real power=0.95)"},
	 { "delete_TemperatureExponential", _wrap_delete_TemperatureExponential, METH_O, "delete_TemperatureExponential(TemperatureExponential self)"},
	 { "TemperatureExponential_swigregister", TemperatureExponential_swigregister, METH_O, NULL},
	 { "TemperatureExponential_swiginit", TemperatureExponential_swiginit, METH_VARARGS, NULL},
	 { "new_ReannealingTrivial", _wrap_new_ReannealingTrivial, METH_NOARGS, "new_ReannealingTrivial() -> ReannealingTrivial"},
	 { "delete_ReannealingTrivial", _wrap_delete_ReannealingTrivial, METH_O, "delete_ReannealingTrivial(ReannealingTrivial self)"},
	 { "ReannealingTrivial_swigregister", ReannealingTrivial_swigregister, METH_O, NULL},
	 { "ReannealingTrivial_swiginit", ReannealingTrivial_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianSimulatedAnnealing", _wrap_new_GaussianSimulatedAnnealing, METH_VARARGS, "GaussianSimulatedAnnealing(SamplerGaussian sampler, ProbabilityBoltzmannDownhill probability, TemperatureExponential temperature, ReannealingTrivial reannealing=ReannealingTrivial(), Real startTemperature=200.0, Real endTemperature=0.01, Size reAnnealSteps=50, GaussianSimulatedAnnealing::ResetScheme resetScheme=ResetToBestPoint, Size resetSteps=150)"},
	 { "delete_GaussianSimulatedAnnealing", _wrap_delete_GaussianSimulatedAnnealing, METH_O, "delete_GaussianSimulatedAnnealing(GaussianSimulatedAnnealing self)"},
	 { "GaussianSimulatedAnnealing_swigregister", GaussianSimulatedAnnealing_swigregister, METH_O, NULL},
	 { "GaussianSimulatedAnnealing_swiginit", GaussianSimulatedAnnealing_swiginit, METH_VARARGS, NULL},
	 { "new_MirrorGaussianSimulatedAnnealing", _wrap_new_MirrorGaussianSimulatedAnnealing, METH_VARARGS, "MirrorGaussianSimulatedAnnealing(SamplerMirrorGaussian sampler, ProbabilityBoltzmannDownhill probability, TemperatureExponential temperature, ReannealingTrivial reannealing=ReannealingTrivial(), Real startTemperature=200.0, Real endTemperature=0.01, Size reAnnealSteps=50, MirrorGaussianSimulatedAnnealing::ResetScheme resetScheme=ResetToBestPoint, Size resetSteps=150)"},
	 { "delete_MirrorGaussianSimulatedAnnealing", _wrap_delete_MirrorGaussianSimulatedAnnealing, METH_O, "delete_MirrorGaussianSimulatedAnnealing(MirrorGaussianSimulatedAnnealing self)"},
	 { "MirrorGaussianSimulatedAnnealing_swigregister", MirrorGaussianSimulatedAnnealing_swigregister, METH_O, NULL},
	 { "MirrorGaussianSimulatedAnnealing_swiginit", MirrorGaussianSimulatedAnnealing_swiginit, METH_VARARGS, NULL},
	 { "new_LogNormalSimulatedAnnealing", _wrap_new_LogNormalSimulatedAnnealing, METH_VARARGS, "LogNormalSimulatedAnnealing(SamplerLogNormal sampler, ProbabilityBoltzmannDownhill probability, TemperatureExponential temperature, ReannealingTrivial reannealing=ReannealingTrivial(), Real startTemperature=10.0, Real endTemperature=0.01, Size reAnnealSteps=50, LogNormalSimulatedAnnealing::ResetScheme resetScheme=ResetToBestPoint, Size resetSteps=150)"},
	 { "delete_LogNormalSimulatedAnnealing", _wrap_delete_LogNormalSimulatedAnnealing, METH_O, "delete_LogNormalSimulatedAnnealing(LogNormalSimulatedAnnealing self)"},
	 { "LogNormalSimulatedAnnealing_swigregister", LogNormalSimulatedAnnealing_swigregister, METH_O, NULL},
	 { "LogNormalSimulatedAnnealing_swiginit", LogNormalSimulatedAnnealing_swiginit, METH_VARARGS, NULL},
	 { "Optimizer_solve", _wrap_Optimizer_solve, METH_VARARGS, "Optimizer_solve(Optimizer self, PyObject * function, Constraint c, OptimizationMethod m, EndCriteria e, Array iv) -> Array"},
	 { "new_Optimizer", _wrap_new_Optimizer, METH_NOARGS, "new_Optimizer() -> Optimizer"},
	 { "delete_Optimizer", _wrap_delete_Optimizer, METH_O, "delete_Optimizer(Optimizer self)"},
	 { "Optimizer_swigregister", Optimizer_swigregister, METH_O, NULL},
	 { "Optimizer_swiginit", Optimizer_swiginit, METH_VARARGS, NULL},
	 { "new_LinearInterpolation", _wrap_new_LinearInterpolation, METH_VARARGS, "new_LinearInterpolation(Array x, Array y) -> LinearInterpolation"},
	 { "LinearInterpolation___call__", _wrap_LinearInterpolation___call__, METH_VARARGS, "LinearInterpolation___call__(LinearInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "delete_LinearInterpolation", _wrap_delete_LinearInterpolation, METH_O, "delete_LinearInterpolation(LinearInterpolation self)"},
	 { "LinearInterpolation_swigregister", LinearInterpolation_swigregister, METH_O, NULL},
	 { "LinearInterpolation_swiginit", LinearInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_LogLinearInterpolation", _wrap_new_LogLinearInterpolation, METH_VARARGS, "new_LogLinearInterpolation(Array x, Array y) -> LogLinearInterpolation"},
	 { "LogLinearInterpolation___call__", _wrap_LogLinearInterpolation___call__, METH_VARARGS, "LogLinearInterpolation___call__(LogLinearInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "delete_LogLinearInterpolation", _wrap_delete_LogLinearInterpolation, METH_O, "delete_LogLinearInterpolation(LogLinearInterpolation self)"},
	 { "LogLinearInterpolation_swigregister", LogLinearInterpolation_swigregister, METH_O, NULL},
	 { "LogLinearInterpolation_swiginit", LogLinearInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_BackwardFlatInterpolation", _wrap_new_BackwardFlatInterpolation, METH_VARARGS, "new_BackwardFlatInterpolation(Array x, Array y) -> BackwardFlatInterpolation"},
	 { "BackwardFlatInterpolation___call__", _wrap_BackwardFlatInterpolation___call__, METH_VARARGS, "BackwardFlatInterpolation___call__(BackwardFlatInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "delete_BackwardFlatInterpolation", _wrap_delete_BackwardFlatInterpolation, METH_O, "delete_BackwardFlatInterpolation(BackwardFlatInterpolation self)"},
	 { "BackwardFlatInterpolation_swigregister", BackwardFlatInterpolation_swigregister, METH_O, NULL},
	 { "BackwardFlatInterpolation_swiginit", BackwardFlatInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardFlatInterpolation", _wrap_new_ForwardFlatInterpolation, METH_VARARGS, "new_ForwardFlatInterpolation(Array x, Array y) -> ForwardFlatInterpolation"},
	 { "ForwardFlatInterpolation___call__", _wrap_ForwardFlatInterpolation___call__, METH_VARARGS, "ForwardFlatInterpolation___call__(ForwardFlatInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "delete_ForwardFlatInterpolation", _wrap_delete_ForwardFlatInterpolation, METH_O, "delete_ForwardFlatInterpolation(ForwardFlatInterpolation self)"},
	 { "ForwardFlatInterpolation_swigregister", ForwardFlatInterpolation_swigregister, METH_O, NULL},
	 { "ForwardFlatInterpolation_swiginit", ForwardFlatInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_CubicNaturalSpline", _wrap_new_CubicNaturalSpline, METH_VARARGS, "new_CubicNaturalSpline(Array x, Array y) -> CubicNaturalSpline"},
	 { "CubicNaturalSpline___call__", _wrap_CubicNaturalSpline___call__, METH_VARARGS, "CubicNaturalSpline___call__(CubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "CubicNaturalSpline_derivative", _wrap_CubicNaturalSpline_derivative, METH_VARARGS, "CubicNaturalSpline_derivative(CubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "CubicNaturalSpline_secondDerivative", _wrap_CubicNaturalSpline_secondDerivative, METH_VARARGS, "CubicNaturalSpline_secondDerivative(CubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "CubicNaturalSpline_primitive", _wrap_CubicNaturalSpline_primitive, METH_VARARGS, "CubicNaturalSpline_primitive(CubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_CubicNaturalSpline", _wrap_delete_CubicNaturalSpline, METH_O, "delete_CubicNaturalSpline(CubicNaturalSpline self)"},
	 { "CubicNaturalSpline_swigregister", CubicNaturalSpline_swigregister, METH_O, NULL},
	 { "CubicNaturalSpline_swiginit", CubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_LogCubicNaturalSpline", _wrap_new_LogCubicNaturalSpline, METH_VARARGS, "new_LogCubicNaturalSpline(Array x, Array y) -> LogCubicNaturalSpline"},
	 { "LogCubicNaturalSpline___call__", _wrap_LogCubicNaturalSpline___call__, METH_VARARGS, "LogCubicNaturalSpline___call__(LogCubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "LogCubicNaturalSpline_derivative", _wrap_LogCubicNaturalSpline_derivative, METH_VARARGS, "LogCubicNaturalSpline_derivative(LogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "LogCubicNaturalSpline_secondDerivative", _wrap_LogCubicNaturalSpline_secondDerivative, METH_VARARGS, "LogCubicNaturalSpline_secondDerivative(LogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "LogCubicNaturalSpline_primitive", _wrap_LogCubicNaturalSpline_primitive, METH_VARARGS, "LogCubicNaturalSpline_primitive(LogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_LogCubicNaturalSpline", _wrap_delete_LogCubicNaturalSpline, METH_O, "delete_LogCubicNaturalSpline(LogCubicNaturalSpline self)"},
	 { "LogCubicNaturalSpline_swigregister", LogCubicNaturalSpline_swigregister, METH_O, NULL},
	 { "LogCubicNaturalSpline_swiginit", LogCubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubicNaturalSpline", _wrap_new_MonotonicCubicNaturalSpline, METH_VARARGS, "new_MonotonicCubicNaturalSpline(Array x, Array y) -> MonotonicCubicNaturalSpline"},
	 { "MonotonicCubicNaturalSpline___call__", _wrap_MonotonicCubicNaturalSpline___call__, METH_VARARGS, "MonotonicCubicNaturalSpline___call__(MonotonicCubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "MonotonicCubicNaturalSpline_derivative", _wrap_MonotonicCubicNaturalSpline_derivative, METH_VARARGS, "MonotonicCubicNaturalSpline_derivative(MonotonicCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicCubicNaturalSpline_secondDerivative", _wrap_MonotonicCubicNaturalSpline_secondDerivative, METH_VARARGS, "MonotonicCubicNaturalSpline_secondDerivative(MonotonicCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicCubicNaturalSpline_primitive", _wrap_MonotonicCubicNaturalSpline_primitive, METH_VARARGS, "MonotonicCubicNaturalSpline_primitive(MonotonicCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_MonotonicCubicNaturalSpline", _wrap_delete_MonotonicCubicNaturalSpline, METH_O, "delete_MonotonicCubicNaturalSpline(MonotonicCubicNaturalSpline self)"},
	 { "MonotonicCubicNaturalSpline_swigregister", MonotonicCubicNaturalSpline_swigregister, METH_O, NULL},
	 { "MonotonicCubicNaturalSpline_swiginit", MonotonicCubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogCubicNaturalSpline", _wrap_new_MonotonicLogCubicNaturalSpline, METH_VARARGS, "new_MonotonicLogCubicNaturalSpline(Array x, Array y) -> MonotonicLogCubicNaturalSpline"},
	 { "MonotonicLogCubicNaturalSpline___call__", _wrap_MonotonicLogCubicNaturalSpline___call__, METH_VARARGS, "MonotonicLogCubicNaturalSpline___call__(MonotonicLogCubicNaturalSpline self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "MonotonicLogCubicNaturalSpline_derivative", _wrap_MonotonicLogCubicNaturalSpline_derivative, METH_VARARGS, "MonotonicLogCubicNaturalSpline_derivative(MonotonicLogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicLogCubicNaturalSpline_secondDerivative", _wrap_MonotonicLogCubicNaturalSpline_secondDerivative, METH_VARARGS, "MonotonicLogCubicNaturalSpline_secondDerivative(MonotonicLogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicLogCubicNaturalSpline_primitive", _wrap_MonotonicLogCubicNaturalSpline_primitive, METH_VARARGS, "MonotonicLogCubicNaturalSpline_primitive(MonotonicLogCubicNaturalSpline self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_MonotonicLogCubicNaturalSpline", _wrap_delete_MonotonicLogCubicNaturalSpline, METH_O, "delete_MonotonicLogCubicNaturalSpline(MonotonicLogCubicNaturalSpline self)"},
	 { "MonotonicLogCubicNaturalSpline_swigregister", MonotonicLogCubicNaturalSpline_swigregister, METH_O, NULL},
	 { "MonotonicLogCubicNaturalSpline_swiginit", MonotonicLogCubicNaturalSpline_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerCubic", _wrap_new_KrugerCubic, METH_VARARGS, "new_KrugerCubic(Array x, Array y) -> KrugerCubic"},
	 { "KrugerCubic___call__", _wrap_KrugerCubic___call__, METH_VARARGS, "KrugerCubic___call__(KrugerCubic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "KrugerCubic_derivative", _wrap_KrugerCubic_derivative, METH_VARARGS, "KrugerCubic_derivative(KrugerCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "KrugerCubic_secondDerivative", _wrap_KrugerCubic_secondDerivative, METH_VARARGS, "KrugerCubic_secondDerivative(KrugerCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "KrugerCubic_primitive", _wrap_KrugerCubic_primitive, METH_VARARGS, "KrugerCubic_primitive(KrugerCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_KrugerCubic", _wrap_delete_KrugerCubic, METH_O, "delete_KrugerCubic(KrugerCubic self)"},
	 { "KrugerCubic_swigregister", KrugerCubic_swigregister, METH_O, NULL},
	 { "KrugerCubic_swiginit", KrugerCubic_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerLogCubic", _wrap_new_KrugerLogCubic, METH_VARARGS, "new_KrugerLogCubic(Array x, Array y) -> KrugerLogCubic"},
	 { "KrugerLogCubic___call__", _wrap_KrugerLogCubic___call__, METH_VARARGS, "KrugerLogCubic___call__(KrugerLogCubic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "KrugerLogCubic_derivative", _wrap_KrugerLogCubic_derivative, METH_VARARGS, "KrugerLogCubic_derivative(KrugerLogCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "KrugerLogCubic_secondDerivative", _wrap_KrugerLogCubic_secondDerivative, METH_VARARGS, "KrugerLogCubic_secondDerivative(KrugerLogCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "KrugerLogCubic_primitive", _wrap_KrugerLogCubic_primitive, METH_VARARGS, "KrugerLogCubic_primitive(KrugerLogCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_KrugerLogCubic", _wrap_delete_KrugerLogCubic, METH_O, "delete_KrugerLogCubic(KrugerLogCubic self)"},
	 { "KrugerLogCubic_swigregister", KrugerLogCubic_swigregister, METH_O, NULL},
	 { "KrugerLogCubic_swiginit", KrugerLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_FritschButlandCubic", _wrap_new_FritschButlandCubic, METH_VARARGS, "new_FritschButlandCubic(Array x, Array y) -> FritschButlandCubic"},
	 { "FritschButlandCubic___call__", _wrap_FritschButlandCubic___call__, METH_VARARGS, "FritschButlandCubic___call__(FritschButlandCubic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "FritschButlandCubic_derivative", _wrap_FritschButlandCubic_derivative, METH_VARARGS, "FritschButlandCubic_derivative(FritschButlandCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "FritschButlandCubic_secondDerivative", _wrap_FritschButlandCubic_secondDerivative, METH_VARARGS, "FritschButlandCubic_secondDerivative(FritschButlandCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "FritschButlandCubic_primitive", _wrap_FritschButlandCubic_primitive, METH_VARARGS, "FritschButlandCubic_primitive(FritschButlandCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_FritschButlandCubic", _wrap_delete_FritschButlandCubic, METH_O, "delete_FritschButlandCubic(FritschButlandCubic self)"},
	 { "FritschButlandCubic_swigregister", FritschButlandCubic_swigregister, METH_O, NULL},
	 { "FritschButlandCubic_swiginit", FritschButlandCubic_swiginit, METH_VARARGS, NULL},
	 { "new_FritschButlandLogCubic", _wrap_new_FritschButlandLogCubic, METH_VARARGS, "new_FritschButlandLogCubic(Array x, Array y) -> FritschButlandLogCubic"},
	 { "FritschButlandLogCubic___call__", _wrap_FritschButlandLogCubic___call__, METH_VARARGS, "FritschButlandLogCubic___call__(FritschButlandLogCubic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "FritschButlandLogCubic_derivative", _wrap_FritschButlandLogCubic_derivative, METH_VARARGS, "FritschButlandLogCubic_derivative(FritschButlandLogCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "FritschButlandLogCubic_secondDerivative", _wrap_FritschButlandLogCubic_secondDerivative, METH_VARARGS, "FritschButlandLogCubic_secondDerivative(FritschButlandLogCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "FritschButlandLogCubic_primitive", _wrap_FritschButlandLogCubic_primitive, METH_VARARGS, "FritschButlandLogCubic_primitive(FritschButlandLogCubic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_FritschButlandLogCubic", _wrap_delete_FritschButlandLogCubic, METH_O, "delete_FritschButlandLogCubic(FritschButlandLogCubic self)"},
	 { "FritschButlandLogCubic_swigregister", FritschButlandLogCubic_swigregister, METH_O, NULL},
	 { "FritschButlandLogCubic_swiginit", FritschButlandLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_Parabolic", _wrap_new_Parabolic, METH_VARARGS, "new_Parabolic(Array x, Array y) -> Parabolic"},
	 { "Parabolic___call__", _wrap_Parabolic___call__, METH_VARARGS, "Parabolic___call__(Parabolic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "Parabolic_derivative", _wrap_Parabolic_derivative, METH_VARARGS, "Parabolic_derivative(Parabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "Parabolic_secondDerivative", _wrap_Parabolic_secondDerivative, METH_VARARGS, "Parabolic_secondDerivative(Parabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "Parabolic_primitive", _wrap_Parabolic_primitive, METH_VARARGS, "Parabolic_primitive(Parabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_Parabolic", _wrap_delete_Parabolic, METH_O, "delete_Parabolic(Parabolic self)"},
	 { "Parabolic_swigregister", Parabolic_swigregister, METH_O, NULL},
	 { "Parabolic_swiginit", Parabolic_swiginit, METH_VARARGS, NULL},
	 { "new_LogParabolic", _wrap_new_LogParabolic, METH_VARARGS, "new_LogParabolic(Array x, Array y) -> LogParabolic"},
	 { "LogParabolic___call__", _wrap_LogParabolic___call__, METH_VARARGS, "LogParabolic___call__(LogParabolic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "LogParabolic_derivative", _wrap_LogParabolic_derivative, METH_VARARGS, "LogParabolic_derivative(LogParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "LogParabolic_secondDerivative", _wrap_LogParabolic_secondDerivative, METH_VARARGS, "LogParabolic_secondDerivative(LogParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "LogParabolic_primitive", _wrap_LogParabolic_primitive, METH_VARARGS, "LogParabolic_primitive(LogParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_LogParabolic", _wrap_delete_LogParabolic, METH_O, "delete_LogParabolic(LogParabolic self)"},
	 { "LogParabolic_swigregister", LogParabolic_swigregister, METH_O, NULL},
	 { "LogParabolic_swiginit", LogParabolic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicParabolic", _wrap_new_MonotonicParabolic, METH_VARARGS, "new_MonotonicParabolic(Array x, Array y) -> MonotonicParabolic"},
	 { "MonotonicParabolic___call__", _wrap_MonotonicParabolic___call__, METH_VARARGS, "MonotonicParabolic___call__(MonotonicParabolic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "MonotonicParabolic_derivative", _wrap_MonotonicParabolic_derivative, METH_VARARGS, "MonotonicParabolic_derivative(MonotonicParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicParabolic_secondDerivative", _wrap_MonotonicParabolic_secondDerivative, METH_VARARGS, "MonotonicParabolic_secondDerivative(MonotonicParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicParabolic_primitive", _wrap_MonotonicParabolic_primitive, METH_VARARGS, "MonotonicParabolic_primitive(MonotonicParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_MonotonicParabolic", _wrap_delete_MonotonicParabolic, METH_O, "delete_MonotonicParabolic(MonotonicParabolic self)"},
	 { "MonotonicParabolic_swigregister", MonotonicParabolic_swigregister, METH_O, NULL},
	 { "MonotonicParabolic_swiginit", MonotonicParabolic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogParabolic", _wrap_new_MonotonicLogParabolic, METH_VARARGS, "new_MonotonicLogParabolic(Array x, Array y) -> MonotonicLogParabolic"},
	 { "MonotonicLogParabolic___call__", _wrap_MonotonicLogParabolic___call__, METH_VARARGS, "MonotonicLogParabolic___call__(MonotonicLogParabolic self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "MonotonicLogParabolic_derivative", _wrap_MonotonicLogParabolic_derivative, METH_VARARGS, "MonotonicLogParabolic_derivative(MonotonicLogParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicLogParabolic_secondDerivative", _wrap_MonotonicLogParabolic_secondDerivative, METH_VARARGS, "MonotonicLogParabolic_secondDerivative(MonotonicLogParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "MonotonicLogParabolic_primitive", _wrap_MonotonicLogParabolic_primitive, METH_VARARGS, "MonotonicLogParabolic_primitive(MonotonicLogParabolic self, Real x, bool extrapolate=False) -> Real"},
	 { "delete_MonotonicLogParabolic", _wrap_delete_MonotonicLogParabolic, METH_O, "delete_MonotonicLogParabolic(MonotonicLogParabolic self)"},
	 { "MonotonicLogParabolic_swigregister", MonotonicLogParabolic_swigregister, METH_O, NULL},
	 { "MonotonicLogParabolic_swiginit", MonotonicLogParabolic_swiginit, METH_VARARGS, NULL},
	 { "new_LagrangeInterpolation", _wrap_new_LagrangeInterpolation, METH_VARARGS, "new_LagrangeInterpolation(Array x, Array y) -> LagrangeInterpolation"},
	 { "LagrangeInterpolation___call__", _wrap_LagrangeInterpolation___call__, METH_VARARGS, "LagrangeInterpolation___call__(LagrangeInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "delete_LagrangeInterpolation", _wrap_delete_LagrangeInterpolation, METH_O, "delete_LagrangeInterpolation(LagrangeInterpolation self)"},
	 { "LagrangeInterpolation_swigregister", LagrangeInterpolation_swigregister, METH_O, NULL},
	 { "LagrangeInterpolation_swiginit", LagrangeInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_BilinearInterpolation", _wrap_new_BilinearInterpolation, METH_VARARGS, "new_BilinearInterpolation(Array x, Array y, Matrix m) -> BilinearInterpolation"},
	 { "BilinearInterpolation___call__", _wrap_BilinearInterpolation___call__, METH_VARARGS, "BilinearInterpolation___call__(BilinearInterpolation self, Real x, Real y, bool allowExtrapolation=False) -> Real"},
	 { "delete_BilinearInterpolation", _wrap_delete_BilinearInterpolation, METH_O, "delete_BilinearInterpolation(BilinearInterpolation self)"},
	 { "BilinearInterpolation_swigregister", BilinearInterpolation_swigregister, METH_O, NULL},
	 { "BilinearInterpolation_swiginit", BilinearInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_BicubicSpline", _wrap_new_BicubicSpline, METH_VARARGS, "new_BicubicSpline(Array x, Array y, Matrix m) -> BicubicSpline"},
	 { "BicubicSpline___call__", _wrap_BicubicSpline___call__, METH_VARARGS, "BicubicSpline___call__(BicubicSpline self, Real x, Real y, bool allowExtrapolation=False) -> Real"},
	 { "delete_BicubicSpline", _wrap_delete_BicubicSpline, METH_O, "delete_BicubicSpline(BicubicSpline self)"},
	 { "BicubicSpline_swigregister", BicubicSpline_swigregister, METH_O, NULL},
	 { "BicubicSpline_swiginit", BicubicSpline_swiginit, METH_VARARGS, NULL},
	 { "delete_CubicInterpolation", _wrap_delete_CubicInterpolation, METH_O, "delete_CubicInterpolation(CubicInterpolation self)"},
	 { "CubicInterpolation_swigregister", CubicInterpolation_swigregister, METH_O, NULL},
	 { "delete_MixedInterpolation", _wrap_delete_MixedInterpolation, METH_O, "delete_MixedInterpolation(MixedInterpolation self)"},
	 { "MixedInterpolation_swigregister", MixedInterpolation_swigregister, METH_O, NULL},
	 { "new_BackwardFlat", _wrap_new_BackwardFlat, METH_NOARGS, "new_BackwardFlat() -> BackwardFlat"},
	 { "delete_BackwardFlat", _wrap_delete_BackwardFlat, METH_O, "delete_BackwardFlat(BackwardFlat self)"},
	 { "BackwardFlat_swigregister", BackwardFlat_swigregister, METH_O, NULL},
	 { "BackwardFlat_swiginit", BackwardFlat_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardFlat", _wrap_new_ForwardFlat, METH_NOARGS, "new_ForwardFlat() -> ForwardFlat"},
	 { "delete_ForwardFlat", _wrap_delete_ForwardFlat, METH_O, "delete_ForwardFlat(ForwardFlat self)"},
	 { "ForwardFlat_swigregister", ForwardFlat_swigregister, METH_O, NULL},
	 { "ForwardFlat_swiginit", ForwardFlat_swiginit, METH_VARARGS, NULL},
	 { "new_Linear", _wrap_new_Linear, METH_NOARGS, "new_Linear() -> Linear"},
	 { "delete_Linear", _wrap_delete_Linear, METH_O, "delete_Linear(Linear self)"},
	 { "Linear_swigregister", Linear_swigregister, METH_O, NULL},
	 { "Linear_swiginit", Linear_swiginit, METH_VARARGS, NULL},
	 { "new_LogLinear", _wrap_new_LogLinear, METH_NOARGS, "new_LogLinear() -> LogLinear"},
	 { "delete_LogLinear", _wrap_delete_LogLinear, METH_O, "delete_LogLinear(LogLinear self)"},
	 { "LogLinear_swigregister", LogLinear_swigregister, METH_O, NULL},
	 { "LogLinear_swiginit", LogLinear_swiginit, METH_VARARGS, NULL},
	 { "new_Cubic", _wrap_new_Cubic, METH_NOARGS, "new_Cubic() -> Cubic"},
	 { "delete_Cubic", _wrap_delete_Cubic, METH_O, "delete_Cubic(Cubic self)"},
	 { "Cubic_swigregister", Cubic_swigregister, METH_O, NULL},
	 { "Cubic_swiginit", Cubic_swiginit, METH_VARARGS, NULL},
	 { "new_Bicubic", _wrap_new_Bicubic, METH_NOARGS, "new_Bicubic() -> Bicubic"},
	 { "delete_Bicubic", _wrap_delete_Bicubic, METH_O, "delete_Bicubic(Bicubic self)"},
	 { "Bicubic_swigregister", Bicubic_swigregister, METH_O, NULL},
	 { "Bicubic_swiginit", Bicubic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubic", _wrap_new_MonotonicCubic, METH_NOARGS, "new_MonotonicCubic() -> MonotonicCubic"},
	 { "delete_MonotonicCubic", _wrap_delete_MonotonicCubic, METH_O, "delete_MonotonicCubic(MonotonicCubic self)"},
	 { "MonotonicCubic_swigregister", MonotonicCubic_swigregister, METH_O, NULL},
	 { "MonotonicCubic_swiginit", MonotonicCubic_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultLogCubic", _wrap_new_DefaultLogCubic, METH_NOARGS, "new_DefaultLogCubic() -> DefaultLogCubic"},
	 { "delete_DefaultLogCubic", _wrap_delete_DefaultLogCubic, METH_O, "delete_DefaultLogCubic(DefaultLogCubic self)"},
	 { "DefaultLogCubic_swigregister", DefaultLogCubic_swigregister, METH_O, NULL},
	 { "DefaultLogCubic_swiginit", DefaultLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogCubic", _wrap_new_MonotonicLogCubic, METH_NOARGS, "new_MonotonicLogCubic() -> MonotonicLogCubic"},
	 { "delete_MonotonicLogCubic", _wrap_delete_MonotonicLogCubic, METH_O, "delete_MonotonicLogCubic(MonotonicLogCubic self)"},
	 { "MonotonicLogCubic_swigregister", MonotonicLogCubic_swigregister, METH_O, NULL},
	 { "MonotonicLogCubic_swiginit", MonotonicLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_SplineCubic", _wrap_new_SplineCubic, METH_NOARGS, "new_SplineCubic() -> SplineCubic"},
	 { "delete_SplineCubic", _wrap_delete_SplineCubic, METH_O, "delete_SplineCubic(SplineCubic self)"},
	 { "SplineCubic_swigregister", SplineCubic_swigregister, METH_O, NULL},
	 { "SplineCubic_swiginit", SplineCubic_swiginit, METH_VARARGS, NULL},
	 { "new_SplineLogCubic", _wrap_new_SplineLogCubic, METH_NOARGS, "new_SplineLogCubic() -> SplineLogCubic"},
	 { "delete_SplineLogCubic", _wrap_delete_SplineLogCubic, METH_O, "delete_SplineLogCubic(SplineLogCubic self)"},
	 { "SplineLogCubic_swigregister", SplineLogCubic_swigregister, METH_O, NULL},
	 { "SplineLogCubic_swiginit", SplineLogCubic_swiginit, METH_VARARGS, NULL},
	 { "new_Kruger", _wrap_new_Kruger, METH_NOARGS, "new_Kruger() -> Kruger"},
	 { "delete_Kruger", _wrap_delete_Kruger, METH_O, "delete_Kruger(Kruger self)"},
	 { "Kruger_swigregister", Kruger_swigregister, METH_O, NULL},
	 { "Kruger_swiginit", Kruger_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerLog", _wrap_new_KrugerLog, METH_NOARGS, "new_KrugerLog() -> KrugerLog"},
	 { "delete_KrugerLog", _wrap_delete_KrugerLog, METH_O, "delete_KrugerLog(KrugerLog self)"},
	 { "KrugerLog_swigregister", KrugerLog_swigregister, METH_O, NULL},
	 { "KrugerLog_swiginit", KrugerLog_swiginit, METH_VARARGS, NULL},
	 { "new_ConvexMonotone", _wrap_new_ConvexMonotone, METH_VARARGS, "ConvexMonotone(Real quadraticity=0.3, Real monotonicity=0.7, bool forcePositive=True)"},
	 { "delete_ConvexMonotone", _wrap_delete_ConvexMonotone, METH_O, "delete_ConvexMonotone(ConvexMonotone self)"},
	 { "ConvexMonotone_swigregister", ConvexMonotone_swigregister, METH_O, NULL},
	 { "ConvexMonotone_swiginit", ConvexMonotone_swiginit, METH_VARARGS, NULL},
	 { "new_LogMixedLinearCubic", (PyCFunction)(void(*)(void))_wrap_new_LogMixedLinearCubic, METH_VARARGS|METH_KEYWORDS, "new_LogMixedLinearCubic(Size n=0, MixedInterpolation::Behavior behavior=ShareRanges, CubicInterpolation::DerivativeApprox da=Spline, bool monotonic=True) -> LogMixedLinearCubic"},
	 { "delete_LogMixedLinearCubic", _wrap_delete_LogMixedLinearCubic, METH_O, "delete_LogMixedLinearCubic(LogMixedLinearCubic self)"},
	 { "LogMixedLinearCubic_swigregister", LogMixedLinearCubic_swigregister, METH_O, NULL},
	 { "LogMixedLinearCubic_swiginit", LogMixedLinearCubic_swiginit, METH_VARARGS, NULL},
	 { "new_SABRInterpolation", (PyCFunction)(void(*)(void))_wrap_new_SABRInterpolation, METH_VARARGS|METH_KEYWORDS, "new_SABRInterpolation(Array x, Array y, Time t, Real forward, Real alpha, Real beta, Real nu, Real rho, bool alphaIsFixed=False, bool betaIsFixed=False, bool nuIsFixed=False, bool rhoIsFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & optMethod=ext::shared_ptr< OptimizationMethod >(), Real const errorAccept=0.0020, bool const useMaxError=False, Size const maxGuesses=50, Real const shift=0.0) -> SABRInterpolation"},
	 { "SABRInterpolation___call__", _wrap_SABRInterpolation___call__, METH_VARARGS, "SABRInterpolation___call__(SABRInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "SABRInterpolation_alpha", _wrap_SABRInterpolation_alpha, METH_O, "SABRInterpolation_alpha(SABRInterpolation self) -> Real"},
	 { "SABRInterpolation_beta", _wrap_SABRInterpolation_beta, METH_O, "SABRInterpolation_beta(SABRInterpolation self) -> Real"},
	 { "SABRInterpolation_rho", _wrap_SABRInterpolation_rho, METH_O, "SABRInterpolation_rho(SABRInterpolation self) -> Real"},
	 { "SABRInterpolation_nu", _wrap_SABRInterpolation_nu, METH_O, "SABRInterpolation_nu(SABRInterpolation self) -> Real"},
	 { "delete_SABRInterpolation", _wrap_delete_SABRInterpolation, METH_O, "delete_SABRInterpolation(SABRInterpolation self)"},
	 { "SABRInterpolation_swigregister", SABRInterpolation_swigregister, METH_O, NULL},
	 { "SABRInterpolation_swiginit", SABRInterpolation_swiginit, METH_VARARGS, NULL},
	 { "RichardsonExtrapolation___call__", _wrap_RichardsonExtrapolation___call__, METH_VARARGS, "\n"
		"RichardsonExtrapolation___call__(RichardsonExtrapolation self, Real t=2.0) -> Real\n"
		"RichardsonExtrapolation___call__(RichardsonExtrapolation self, Real t, Real s) -> Real\n"
		""},
	 { "new_RichardsonExtrapolation", _wrap_new_RichardsonExtrapolation, METH_VARARGS, "RichardsonExtrapolation(PyObject * fct, Real delta_h, Real n=Null< Real >())"},
	 { "delete_RichardsonExtrapolation", _wrap_delete_RichardsonExtrapolation, METH_O, "delete_RichardsonExtrapolation(RichardsonExtrapolation self)"},
	 { "RichardsonExtrapolation_swigregister", RichardsonExtrapolation_swigregister, METH_O, NULL},
	 { "RichardsonExtrapolation_swiginit", RichardsonExtrapolation_swiginit, METH_VARARGS, NULL},
	 { "new_ChebyshevInterpolation", _wrap_new_ChebyshevInterpolation, METH_VARARGS, "\n"
		"ChebyshevInterpolation(Array f, ChebyshevInterpolation::PointsType pointsType=SecondKind)\n"
		"ChebyshevInterpolation(Size n, PyObject * fct, ChebyshevInterpolation::PointsType pointsType=SecondKind)\n"
		""},
	 { "ChebyshevInterpolation___call__", _wrap_ChebyshevInterpolation___call__, METH_VARARGS, "ChebyshevInterpolation___call__(ChebyshevInterpolation self, Real z, bool allowExtrapolation=False) -> Real"},
	 { "ChebyshevInterpolation_nodes", _wrap_ChebyshevInterpolation_nodes, METH_VARARGS, "ChebyshevInterpolation_nodes(Size n, ChebyshevInterpolation::PointsType pointsType) -> Array"},
	 { "delete_ChebyshevInterpolation", _wrap_delete_ChebyshevInterpolation, METH_O, "delete_ChebyshevInterpolation(ChebyshevInterpolation self)"},
	 { "ChebyshevInterpolation_swigregister", ChebyshevInterpolation_swigregister, METH_O, NULL},
	 { "ChebyshevInterpolation_swiginit", ChebyshevInterpolation_swiginit, METH_VARARGS, NULL},
	 { "new_ConvexMonotoneInterpolation", _wrap_new_ConvexMonotoneInterpolation, METH_VARARGS, "ConvexMonotoneInterpolation(Array x, Array y, Real quadraticity=0.3, Real monotonicity=0.7, bool forcePositive=True)"},
	 { "ConvexMonotoneInterpolation___call__", _wrap_ConvexMonotoneInterpolation___call__, METH_VARARGS, "ConvexMonotoneInterpolation___call__(ConvexMonotoneInterpolation self, Real x, bool allowExtrapolation=False) -> Real"},
	 { "delete_ConvexMonotoneInterpolation", _wrap_delete_ConvexMonotoneInterpolation, METH_O, "delete_ConvexMonotoneInterpolation(ConvexMonotoneInterpolation self)"},
	 { "ConvexMonotoneInterpolation_swigregister", ConvexMonotoneInterpolation_swigregister, METH_O, NULL},
	 { "ConvexMonotoneInterpolation_swiginit", ConvexMonotoneInterpolation_swiginit, METH_VARARGS, NULL},
	 { "TermStructure_dayCounter", _wrap_TermStructure_dayCounter, METH_O, "TermStructure_dayCounter(TermStructure self) -> DayCounter"},
	 { "TermStructure_timeFromReference", _wrap_TermStructure_timeFromReference, METH_VARARGS, "TermStructure_timeFromReference(TermStructure self, Date date) -> Time"},
	 { "TermStructure_calendar", _wrap_TermStructure_calendar, METH_O, "TermStructure_calendar(TermStructure self) -> Calendar"},
	 { "TermStructure_referenceDate", _wrap_TermStructure_referenceDate, METH_O, "TermStructure_referenceDate(TermStructure self) -> Date"},
	 { "TermStructure_maxDate", _wrap_TermStructure_maxDate, METH_O, "TermStructure_maxDate(TermStructure self) -> Date"},
	 { "TermStructure_maxTime", _wrap_TermStructure_maxTime, METH_O, "TermStructure_maxTime(TermStructure self) -> Time"},
	 { "TermStructure_enableExtrapolation", _wrap_TermStructure_enableExtrapolation, METH_O, "TermStructure_enableExtrapolation(TermStructure self)"},
	 { "TermStructure_disableExtrapolation", _wrap_TermStructure_disableExtrapolation, METH_O, "TermStructure_disableExtrapolation(TermStructure self)"},
	 { "TermStructure_allowsExtrapolation", _wrap_TermStructure_allowsExtrapolation, METH_O, "TermStructure_allowsExtrapolation(TermStructure self) -> bool"},
	 { "delete_TermStructure", _wrap_delete_TermStructure, METH_O, "delete_TermStructure(TermStructure self)"},
	 { "TermStructure_swigregister", TermStructure_swigregister, METH_O, NULL},
	 { "YieldTermStructure_discount", _wrap_YieldTermStructure_discount, METH_VARARGS, "\n"
		"YieldTermStructure_discount(YieldTermStructure self, Date arg2, bool extrapolate=False) -> DiscountFactor\n"
		"YieldTermStructure_discount(YieldTermStructure self, Time arg2, bool extrapolate=False) -> DiscountFactor\n"
		""},
	 { "YieldTermStructure_zeroRate", _wrap_YieldTermStructure_zeroRate, METH_VARARGS, "\n"
		"YieldTermStructure_zeroRate(YieldTermStructure self, Date d, DayCounter arg3, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		"YieldTermStructure_zeroRate(YieldTermStructure self, Time t, Compounding arg3, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		""},
	 { "YieldTermStructure_forwardRate", _wrap_YieldTermStructure_forwardRate, METH_VARARGS, "\n"
		"YieldTermStructure_forwardRate(YieldTermStructure self, Date d1, Date d2, DayCounter arg4, Compounding arg5, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		"YieldTermStructure_forwardRate(YieldTermStructure self, Time t1, Time t2, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		""},
	 { "delete_YieldTermStructure", _wrap_delete_YieldTermStructure, METH_O, "delete_YieldTermStructure(YieldTermStructure self)"},
	 { "YieldTermStructure_swigregister", YieldTermStructure_swigregister, METH_O, NULL},
	 { "new_YieldTermStructureHandle", _wrap_new_YieldTermStructureHandle, METH_VARARGS, "YieldTermStructureHandle(ext::shared_ptr< YieldTermStructure > const & arg1=ext::shared_ptr())"},
	 { "YieldTermStructureHandle___deref__", _wrap_YieldTermStructureHandle___deref__, METH_O, "YieldTermStructureHandle___deref__(YieldTermStructureHandle self) -> ext::shared_ptr< YieldTermStructure >"},
	 { "YieldTermStructureHandle_currentLink", _wrap_YieldTermStructureHandle_currentLink, METH_O, "YieldTermStructureHandle_currentLink(YieldTermStructureHandle self) -> ext::shared_ptr< YieldTermStructure >"},
	 { "YieldTermStructureHandle___nonzero__", _wrap_YieldTermStructureHandle___nonzero__, METH_O, "YieldTermStructureHandle___nonzero__(YieldTermStructureHandle self) -> bool"},
	 { "YieldTermStructureHandle___bool__", _wrap_YieldTermStructureHandle___bool__, METH_O, "YieldTermStructureHandle___bool__(YieldTermStructureHandle self) -> bool"},
	 { "YieldTermStructureHandle_asObservable", _wrap_YieldTermStructureHandle_asObservable, METH_O, "YieldTermStructureHandle_asObservable(YieldTermStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_YieldTermStructureHandle", _wrap_delete_YieldTermStructureHandle, METH_O, "delete_YieldTermStructureHandle(YieldTermStructureHandle self)"},
	 { "YieldTermStructureHandle_discount", _wrap_YieldTermStructureHandle_discount, METH_VARARGS, "\n"
		"YieldTermStructureHandle_discount(YieldTermStructureHandle self, Date arg2, bool extrapolate=False) -> DiscountFactor\n"
		"YieldTermStructureHandle_discount(YieldTermStructureHandle self, Time arg2, bool extrapolate=False) -> DiscountFactor\n"
		""},
	 { "YieldTermStructureHandle_zeroRate", _wrap_YieldTermStructureHandle_zeroRate, METH_VARARGS, "\n"
		"YieldTermStructureHandle_zeroRate(YieldTermStructureHandle self, Date d, DayCounter arg3, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		"YieldTermStructureHandle_zeroRate(YieldTermStructureHandle self, Time t, Compounding arg3, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		""},
	 { "YieldTermStructureHandle_forwardRate", _wrap_YieldTermStructureHandle_forwardRate, METH_VARARGS, "\n"
		"YieldTermStructureHandle_forwardRate(YieldTermStructureHandle self, Date d1, Date d2, DayCounter arg4, Compounding arg5, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		"YieldTermStructureHandle_forwardRate(YieldTermStructureHandle self, Time t1, Time t2, Compounding arg4, Frequency f=Annual, bool extrapolate=False) -> InterestRate\n"
		""},
	 { "YieldTermStructureHandle_dayCounter", _wrap_YieldTermStructureHandle_dayCounter, METH_O, "YieldTermStructureHandle_dayCounter(YieldTermStructureHandle self) -> DayCounter"},
	 { "YieldTermStructureHandle_timeFromReference", _wrap_YieldTermStructureHandle_timeFromReference, METH_VARARGS, "YieldTermStructureHandle_timeFromReference(YieldTermStructureHandle self, Date date) -> Time"},
	 { "YieldTermStructureHandle_calendar", _wrap_YieldTermStructureHandle_calendar, METH_O, "YieldTermStructureHandle_calendar(YieldTermStructureHandle self) -> Calendar"},
	 { "YieldTermStructureHandle_referenceDate", _wrap_YieldTermStructureHandle_referenceDate, METH_O, "YieldTermStructureHandle_referenceDate(YieldTermStructureHandle self) -> Date"},
	 { "YieldTermStructureHandle_maxDate", _wrap_YieldTermStructureHandle_maxDate, METH_O, "YieldTermStructureHandle_maxDate(YieldTermStructureHandle self) -> Date"},
	 { "YieldTermStructureHandle_maxTime", _wrap_YieldTermStructureHandle_maxTime, METH_O, "YieldTermStructureHandle_maxTime(YieldTermStructureHandle self) -> Time"},
	 { "YieldTermStructureHandle_enableExtrapolation", _wrap_YieldTermStructureHandle_enableExtrapolation, METH_O, "YieldTermStructureHandle_enableExtrapolation(YieldTermStructureHandle self)"},
	 { "YieldTermStructureHandle_disableExtrapolation", _wrap_YieldTermStructureHandle_disableExtrapolation, METH_O, "YieldTermStructureHandle_disableExtrapolation(YieldTermStructureHandle self)"},
	 { "YieldTermStructureHandle_allowsExtrapolation", _wrap_YieldTermStructureHandle_allowsExtrapolation, METH_O, "YieldTermStructureHandle_allowsExtrapolation(YieldTermStructureHandle self) -> bool"},
	 { "YieldTermStructureHandle_swigregister", YieldTermStructureHandle_swigregister, METH_O, NULL},
	 { "YieldTermStructureHandle_swiginit", YieldTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableYieldTermStructureHandle", _wrap_new_RelinkableYieldTermStructureHandle, METH_VARARGS, "RelinkableYieldTermStructureHandle(ext::shared_ptr< YieldTermStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableYieldTermStructureHandle_linkTo", _wrap_RelinkableYieldTermStructureHandle_linkTo, METH_VARARGS, "RelinkableYieldTermStructureHandle_linkTo(RelinkableYieldTermStructureHandle self, ext::shared_ptr< YieldTermStructure > const & arg2)"},
	 { "RelinkableYieldTermStructureHandle_reset", _wrap_RelinkableYieldTermStructureHandle_reset, METH_O, "RelinkableYieldTermStructureHandle_reset(RelinkableYieldTermStructureHandle self)"},
	 { "delete_RelinkableYieldTermStructureHandle", _wrap_delete_RelinkableYieldTermStructureHandle, METH_O, "delete_RelinkableYieldTermStructureHandle(RelinkableYieldTermStructureHandle self)"},
	 { "RelinkableYieldTermStructureHandle_swigregister", RelinkableYieldTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableYieldTermStructureHandle_swiginit", RelinkableYieldTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_ImpliedTermStructure", _wrap_new_ImpliedTermStructure, METH_VARARGS, "new_ImpliedTermStructure(YieldTermStructureHandle curveHandle, Date referenceDate) -> ImpliedTermStructure"},
	 { "delete_ImpliedTermStructure", _wrap_delete_ImpliedTermStructure, METH_O, "delete_ImpliedTermStructure(ImpliedTermStructure self)"},
	 { "ImpliedTermStructure_swigregister", ImpliedTermStructure_swigregister, METH_O, NULL},
	 { "ImpliedTermStructure_swiginit", ImpliedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroSpreadedTermStructure", _wrap_new_ZeroSpreadedTermStructure, METH_VARARGS, "ZeroSpreadedTermStructure(YieldTermStructureHandle curveHandle, QuoteHandle spreadHandle, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter())"},
	 { "delete_ZeroSpreadedTermStructure", _wrap_delete_ZeroSpreadedTermStructure, METH_O, "delete_ZeroSpreadedTermStructure(ZeroSpreadedTermStructure self)"},
	 { "ZeroSpreadedTermStructure_swigregister", ZeroSpreadedTermStructure_swigregister, METH_O, NULL},
	 { "ZeroSpreadedTermStructure_swiginit", ZeroSpreadedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardSpreadedTermStructure", _wrap_new_ForwardSpreadedTermStructure, METH_VARARGS, "new_ForwardSpreadedTermStructure(YieldTermStructureHandle curveHandle, QuoteHandle spreadHandle) -> ForwardSpreadedTermStructure"},
	 { "delete_ForwardSpreadedTermStructure", _wrap_delete_ForwardSpreadedTermStructure, METH_O, "delete_ForwardSpreadedTermStructure(ForwardSpreadedTermStructure self)"},
	 { "ForwardSpreadedTermStructure_swigregister", ForwardSpreadedTermStructure_swigregister, METH_O, NULL},
	 { "ForwardSpreadedTermStructure_swiginit", ForwardSpreadedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseZeroSpreadedTermStructure", _wrap_new_PiecewiseZeroSpreadedTermStructure, METH_VARARGS, "PiecewiseZeroSpreadedTermStructure(YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter(), Linear factory=Linear())"},
	 { "delete_PiecewiseZeroSpreadedTermStructure", _wrap_delete_PiecewiseZeroSpreadedTermStructure, METH_O, "delete_PiecewiseZeroSpreadedTermStructure(PiecewiseZeroSpreadedTermStructure self)"},
	 { "PiecewiseZeroSpreadedTermStructure_swigregister", PiecewiseZeroSpreadedTermStructure_swigregister, METH_O, NULL},
	 { "PiecewiseZeroSpreadedTermStructure_swiginit", PiecewiseZeroSpreadedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadedLinearZeroInterpolatedTermStructure", _wrap_new_SpreadedLinearZeroInterpolatedTermStructure, METH_VARARGS, "SpreadedLinearZeroInterpolatedTermStructure(YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter(), Linear factory=Linear())"},
	 { "delete_SpreadedLinearZeroInterpolatedTermStructure", _wrap_delete_SpreadedLinearZeroInterpolatedTermStructure, METH_O, "delete_SpreadedLinearZeroInterpolatedTermStructure(SpreadedLinearZeroInterpolatedTermStructure self)"},
	 { "SpreadedLinearZeroInterpolatedTermStructure_swigregister", SpreadedLinearZeroInterpolatedTermStructure_swigregister, METH_O, NULL},
	 { "SpreadedLinearZeroInterpolatedTermStructure_swiginit", SpreadedLinearZeroInterpolatedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadedBackwardFlatZeroInterpolatedTermStructure", _wrap_new_SpreadedBackwardFlatZeroInterpolatedTermStructure, METH_VARARGS, "SpreadedBackwardFlatZeroInterpolatedTermStructure(YieldTermStructureHandle curveHandle, QuoteHandleVector spreadHandles, DateVector dates, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency, DayCounter dc=DayCounter(), BackwardFlat factory=BackwardFlat())"},
	 { "delete_SpreadedBackwardFlatZeroInterpolatedTermStructure", _wrap_delete_SpreadedBackwardFlatZeroInterpolatedTermStructure, METH_O, "delete_SpreadedBackwardFlatZeroInterpolatedTermStructure(SpreadedBackwardFlatZeroInterpolatedTermStructure self)"},
	 { "SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister", SpreadedBackwardFlatZeroInterpolatedTermStructure_swigregister, METH_O, NULL},
	 { "SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit", SpreadedBackwardFlatZeroInterpolatedTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_FlatForward", _wrap_new_FlatForward, METH_VARARGS, "\n"
		"FlatForward(Date referenceDate, QuoteHandle forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual)\n"
		"FlatForward(Date referenceDate, Rate forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual)\n"
		"FlatForward(Integer settlementDays, Calendar calendar, QuoteHandle forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual)\n"
		"FlatForward(Integer settlementDays, Calendar calendar, Rate forward, DayCounter dayCounter, Compounding compounding=QuantLib::Continuous, Frequency frequency=QuantLib::Annual)\n"
		""},
	 { "delete_FlatForward", _wrap_delete_FlatForward, METH_O, "delete_FlatForward(FlatForward self)"},
	 { "FlatForward_swigregister", FlatForward_swigregister, METH_O, NULL},
	 { "FlatForward_swiginit", FlatForward_swiginit, METH_VARARGS, NULL},
	 { "new_UltimateForwardTermStructure", _wrap_new_UltimateForwardTermStructure, METH_VARARGS, "new_UltimateForwardTermStructure(YieldTermStructureHandle curveHandle, QuoteHandle lastLiquidForwardRate, QuoteHandle ultimateForwardRate, Period firstSmoothingPoint, Real alpha) -> UltimateForwardTermStructure"},
	 { "delete_UltimateForwardTermStructure", _wrap_delete_UltimateForwardTermStructure, METH_O, "delete_UltimateForwardTermStructure(UltimateForwardTermStructure self)"},
	 { "UltimateForwardTermStructure_swigregister", UltimateForwardTermStructure_swigregister, METH_O, NULL},
	 { "UltimateForwardTermStructure_swiginit", UltimateForwardTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeZeroYieldStructure", _wrap_new_CompositeZeroYieldStructure, METH_VARARGS, "CompositeZeroYieldStructure(YieldTermStructureHandle h1, YieldTermStructureHandle h2, PyObject * function, Compounding comp=QuantLib::Continuous, Frequency freq=QuantLib::NoFrequency)"},
	 { "delete_CompositeZeroYieldStructure", _wrap_delete_CompositeZeroYieldStructure, METH_O, "delete_CompositeZeroYieldStructure(CompositeZeroYieldStructure self)"},
	 { "CompositeZeroYieldStructure_swigregister", CompositeZeroYieldStructure_swigregister, METH_O, NULL},
	 { "CompositeZeroYieldStructure_swiginit", CompositeZeroYieldStructure_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoTermStructure", _wrap_new_QuantoTermStructure, METH_VARARGS, "new_QuantoTermStructure(YieldTermStructureHandle underlyingDividendTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle foreignRiskFreeTS, BlackVolTermStructureHandle underlyingBlackVolTS, Real strike, BlackVolTermStructureHandle exchRateBlackVolTS, Real exchRateATMlevel, Real underlyingExchRateCorrelation) -> QuantoTermStructure"},
	 { "delete_QuantoTermStructure", _wrap_delete_QuantoTermStructure, METH_O, "delete_QuantoTermStructure(QuantoTermStructure self)"},
	 { "QuantoTermStructure_swigregister", QuantoTermStructure_swigregister, METH_O, NULL},
	 { "QuantoTermStructure_swiginit", QuantoTermStructure_swiginit, METH_VARARGS, NULL},
	 { "new_RealTimeSeries", _wrap_new_RealTimeSeries, METH_VARARGS, "\n"
		"RealTimeSeries()\n"
		"new_RealTimeSeries(DateVector d, DoubleVector v) -> RealTimeSeries\n"
		""},
	 { "RealTimeSeries_dates", _wrap_RealTimeSeries_dates, METH_O, "RealTimeSeries_dates(RealTimeSeries self) -> DateVector"},
	 { "RealTimeSeries_values", _wrap_RealTimeSeries_values, METH_O, "RealTimeSeries_values(RealTimeSeries self) -> DoubleVector"},
	 { "RealTimeSeries___len__", _wrap_RealTimeSeries___len__, METH_O, "RealTimeSeries___len__(RealTimeSeries self) -> Size"},
	 { "RealTimeSeries___getitem__", _wrap_RealTimeSeries___getitem__, METH_VARARGS, "RealTimeSeries___getitem__(RealTimeSeries self, Date d) -> double"},
	 { "RealTimeSeries___setitem__", _wrap_RealTimeSeries___setitem__, METH_VARARGS, "RealTimeSeries___setitem__(RealTimeSeries self, Date d, double const & value)"},
	 { "delete_RealTimeSeries", _wrap_delete_RealTimeSeries, METH_O, "delete_RealTimeSeries(RealTimeSeries self)"},
	 { "RealTimeSeries_swigregister", RealTimeSeries_swigregister, METH_O, NULL},
	 { "RealTimeSeries_swiginit", RealTimeSeries_swiginit, METH_VARARGS, NULL},
	 { "new_IntervalPriceTimeSeries", _wrap_new_IntervalPriceTimeSeries, METH_VARARGS, "\n"
		"IntervalPriceTimeSeries()\n"
		"new_IntervalPriceTimeSeries(DateVector d, IntervalPriceVector v) -> IntervalPriceTimeSeries\n"
		""},
	 { "IntervalPriceTimeSeries_dates", _wrap_IntervalPriceTimeSeries_dates, METH_O, "IntervalPriceTimeSeries_dates(IntervalPriceTimeSeries self) -> DateVector"},
	 { "IntervalPriceTimeSeries_values", _wrap_IntervalPriceTimeSeries_values, METH_O, "IntervalPriceTimeSeries_values(IntervalPriceTimeSeries self) -> IntervalPriceVector"},
	 { "IntervalPriceTimeSeries___len__", _wrap_IntervalPriceTimeSeries___len__, METH_O, "IntervalPriceTimeSeries___len__(IntervalPriceTimeSeries self) -> Size"},
	 { "IntervalPriceTimeSeries___getitem__", _wrap_IntervalPriceTimeSeries___getitem__, METH_VARARGS, "IntervalPriceTimeSeries___getitem__(IntervalPriceTimeSeries self, Date d) -> IntervalPrice"},
	 { "IntervalPriceTimeSeries___setitem__", _wrap_IntervalPriceTimeSeries___setitem__, METH_VARARGS, "IntervalPriceTimeSeries___setitem__(IntervalPriceTimeSeries self, Date d, IntervalPrice value)"},
	 { "delete_IntervalPriceTimeSeries", _wrap_delete_IntervalPriceTimeSeries, METH_O, "delete_IntervalPriceTimeSeries(IntervalPriceTimeSeries self)"},
	 { "IntervalPriceTimeSeries_swigregister", IntervalPriceTimeSeries_swigregister, METH_O, NULL},
	 { "IntervalPriceTimeSeries_swiginit", IntervalPriceTimeSeries_swiginit, METH_VARARGS, NULL},
	 { "IntervalPriceVector_iterator", _wrap_IntervalPriceVector_iterator, METH_O, "IntervalPriceVector_iterator(IntervalPriceVector self) -> SwigPyIterator"},
	 { "IntervalPriceVector___nonzero__", _wrap_IntervalPriceVector___nonzero__, METH_O, "IntervalPriceVector___nonzero__(IntervalPriceVector self) -> bool"},
	 { "IntervalPriceVector___bool__", _wrap_IntervalPriceVector___bool__, METH_O, "IntervalPriceVector___bool__(IntervalPriceVector self) -> bool"},
	 { "IntervalPriceVector___len__", _wrap_IntervalPriceVector___len__, METH_O, "IntervalPriceVector___len__(IntervalPriceVector self) -> std::vector< IntervalPrice >::size_type"},
	 { "IntervalPriceVector___getslice__", _wrap_IntervalPriceVector___getslice__, METH_VARARGS, "IntervalPriceVector___getslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j) -> IntervalPriceVector"},
	 { "IntervalPriceVector___setslice__", _wrap_IntervalPriceVector___setslice__, METH_VARARGS, "\n"
		"IntervalPriceVector___setslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j)\n"
		"IntervalPriceVector___setslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j, IntervalPriceVector v)\n"
		""},
	 { "IntervalPriceVector___delslice__", _wrap_IntervalPriceVector___delslice__, METH_VARARGS, "IntervalPriceVector___delslice__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, std::vector< IntervalPrice >::difference_type j)"},
	 { "IntervalPriceVector___delitem__", _wrap_IntervalPriceVector___delitem__, METH_VARARGS, "\n"
		"IntervalPriceVector___delitem__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i)\n"
		"IntervalPriceVector___delitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "IntervalPriceVector___getitem__", _wrap_IntervalPriceVector___getitem__, METH_VARARGS, "\n"
		"IntervalPriceVector___getitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice) -> IntervalPriceVector\n"
		"IntervalPriceVector___getitem__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i) -> IntervalPrice\n"
		""},
	 { "IntervalPriceVector___setitem__", _wrap_IntervalPriceVector___setitem__, METH_VARARGS, "\n"
		"IntervalPriceVector___setitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice, IntervalPriceVector v)\n"
		"IntervalPriceVector___setitem__(IntervalPriceVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"IntervalPriceVector___setitem__(IntervalPriceVector self, std::vector< IntervalPrice >::difference_type i, IntervalPrice x)\n"
		""},
	 { "IntervalPriceVector_pop", _wrap_IntervalPriceVector_pop, METH_O, "IntervalPriceVector_pop(IntervalPriceVector self) -> IntervalPrice"},
	 { "IntervalPriceVector_append", _wrap_IntervalPriceVector_append, METH_VARARGS, "IntervalPriceVector_append(IntervalPriceVector self, IntervalPrice x)"},
	 { "IntervalPriceVector_empty", _wrap_IntervalPriceVector_empty, METH_O, "IntervalPriceVector_empty(IntervalPriceVector self) -> bool"},
	 { "IntervalPriceVector_size", _wrap_IntervalPriceVector_size, METH_O, "IntervalPriceVector_size(IntervalPriceVector self) -> std::vector< IntervalPrice >::size_type"},
	 { "IntervalPriceVector_swap", _wrap_IntervalPriceVector_swap, METH_VARARGS, "IntervalPriceVector_swap(IntervalPriceVector self, IntervalPriceVector v)"},
	 { "IntervalPriceVector_begin", _wrap_IntervalPriceVector_begin, METH_O, "IntervalPriceVector_begin(IntervalPriceVector self) -> std::vector< IntervalPrice >::iterator"},
	 { "IntervalPriceVector_end", _wrap_IntervalPriceVector_end, METH_O, "IntervalPriceVector_end(IntervalPriceVector self) -> std::vector< IntervalPrice >::iterator"},
	 { "IntervalPriceVector_rbegin", _wrap_IntervalPriceVector_rbegin, METH_O, "IntervalPriceVector_rbegin(IntervalPriceVector self) -> std::vector< IntervalPrice >::reverse_iterator"},
	 { "IntervalPriceVector_rend", _wrap_IntervalPriceVector_rend, METH_O, "IntervalPriceVector_rend(IntervalPriceVector self) -> std::vector< IntervalPrice >::reverse_iterator"},
	 { "IntervalPriceVector_clear", _wrap_IntervalPriceVector_clear, METH_O, "IntervalPriceVector_clear(IntervalPriceVector self)"},
	 { "IntervalPriceVector_get_allocator", _wrap_IntervalPriceVector_get_allocator, METH_O, "IntervalPriceVector_get_allocator(IntervalPriceVector self) -> std::vector< IntervalPrice >::allocator_type"},
	 { "IntervalPriceVector_pop_back", _wrap_IntervalPriceVector_pop_back, METH_O, "IntervalPriceVector_pop_back(IntervalPriceVector self)"},
	 { "IntervalPriceVector_erase", _wrap_IntervalPriceVector_erase, METH_VARARGS, "\n"
		"IntervalPriceVector_erase(IntervalPriceVector self, std::vector< IntervalPrice >::iterator pos) -> std::vector< IntervalPrice >::iterator\n"
		"IntervalPriceVector_erase(IntervalPriceVector self, std::vector< IntervalPrice >::iterator first, std::vector< IntervalPrice >::iterator last) -> std::vector< IntervalPrice >::iterator\n"
		""},
	 { "new_IntervalPriceVector", _wrap_new_IntervalPriceVector, METH_VARARGS, "\n"
		"IntervalPriceVector()\n"
		"IntervalPriceVector(IntervalPriceVector other)\n"
		"IntervalPriceVector(std::vector< IntervalPrice >::size_type size)\n"
		"new_IntervalPriceVector(std::vector< IntervalPrice >::size_type size, IntervalPrice value) -> IntervalPriceVector\n"
		""},
	 { "IntervalPriceVector_push_back", _wrap_IntervalPriceVector_push_back, METH_VARARGS, "IntervalPriceVector_push_back(IntervalPriceVector self, IntervalPrice x)"},
	 { "IntervalPriceVector_front", _wrap_IntervalPriceVector_front, METH_O, "IntervalPriceVector_front(IntervalPriceVector self) -> IntervalPrice"},
	 { "IntervalPriceVector_back", _wrap_IntervalPriceVector_back, METH_O, "IntervalPriceVector_back(IntervalPriceVector self) -> IntervalPrice"},
	 { "IntervalPriceVector_assign", _wrap_IntervalPriceVector_assign, METH_VARARGS, "IntervalPriceVector_assign(IntervalPriceVector self, std::vector< IntervalPrice >::size_type n, IntervalPrice x)"},
	 { "IntervalPriceVector_resize", _wrap_IntervalPriceVector_resize, METH_VARARGS, "\n"
		"IntervalPriceVector_resize(IntervalPriceVector self, std::vector< IntervalPrice >::size_type new_size)\n"
		"IntervalPriceVector_resize(IntervalPriceVector self, std::vector< IntervalPrice >::size_type new_size, IntervalPrice x)\n"
		""},
	 { "IntervalPriceVector_insert", _wrap_IntervalPriceVector_insert, METH_VARARGS, "\n"
		"IntervalPriceVector_insert(IntervalPriceVector self, std::vector< IntervalPrice >::iterator pos, IntervalPrice x) -> std::vector< IntervalPrice >::iterator\n"
		"IntervalPriceVector_insert(IntervalPriceVector self, std::vector< IntervalPrice >::iterator pos, std::vector< IntervalPrice >::size_type n, IntervalPrice x)\n"
		""},
	 { "IntervalPriceVector_reserve", _wrap_IntervalPriceVector_reserve, METH_VARARGS, "IntervalPriceVector_reserve(IntervalPriceVector self, std::vector< IntervalPrice >::size_type n)"},
	 { "IntervalPriceVector_capacity", _wrap_IntervalPriceVector_capacity, METH_O, "IntervalPriceVector_capacity(IntervalPriceVector self) -> std::vector< IntervalPrice >::size_type"},
	 { "delete_IntervalPriceVector", _wrap_delete_IntervalPriceVector, METH_O, "delete_IntervalPriceVector(IntervalPriceVector self)"},
	 { "IntervalPriceVector_swigregister", IntervalPriceVector_swigregister, METH_O, NULL},
	 { "IntervalPriceVector_swiginit", IntervalPriceVector_swiginit, METH_VARARGS, NULL},
	 { "new_IntervalPrice", _wrap_new_IntervalPrice, METH_VARARGS, "new_IntervalPrice(Real arg1, Real arg2, Real arg3, Real arg4) -> IntervalPrice"},
	 { "IntervalPrice_setValue", _wrap_IntervalPrice_setValue, METH_VARARGS, "IntervalPrice_setValue(IntervalPrice self, Real arg2, IntervalPrice::Type arg3)"},
	 { "IntervalPrice_setValues", _wrap_IntervalPrice_setValues, METH_VARARGS, "IntervalPrice_setValues(IntervalPrice self, Real arg2, Real arg3, Real arg4, Real arg5)"},
	 { "IntervalPrice_value", _wrap_IntervalPrice_value, METH_VARARGS, "IntervalPrice_value(IntervalPrice self, IntervalPrice::Type t) -> Real"},
	 { "IntervalPrice_open", _wrap_IntervalPrice_open, METH_O, "IntervalPrice_open(IntervalPrice self) -> Real"},
	 { "IntervalPrice_close", _wrap_IntervalPrice_close, METH_O, "IntervalPrice_close(IntervalPrice self) -> Real"},
	 { "IntervalPrice_high", _wrap_IntervalPrice_high, METH_O, "IntervalPrice_high(IntervalPrice self) -> Real"},
	 { "IntervalPrice_low", _wrap_IntervalPrice_low, METH_O, "IntervalPrice_low(IntervalPrice self) -> Real"},
	 { "IntervalPrice_makeSeries", _wrap_IntervalPrice_makeSeries, METH_VARARGS, "IntervalPrice_makeSeries(DateVector d, DoubleVector open, DoubleVector close, DoubleVector high, DoubleVector low) -> IntervalPriceTimeSeries"},
	 { "IntervalPrice_extractValues", _wrap_IntervalPrice_extractValues, METH_VARARGS, "IntervalPrice_extractValues(IntervalPriceTimeSeries arg1, IntervalPrice::Type t) -> DoubleVector"},
	 { "IntervalPrice_extractComponent", _wrap_IntervalPrice_extractComponent, METH_VARARGS, "IntervalPrice_extractComponent(IntervalPriceTimeSeries arg1, IntervalPrice::Type t) -> RealTimeSeries"},
	 { "delete_IntervalPrice", _wrap_delete_IntervalPrice, METH_O, "delete_IntervalPrice(IntervalPrice self)"},
	 { "IntervalPrice_swigregister", IntervalPrice_swigregister, METH_O, NULL},
	 { "IntervalPrice_swiginit", IntervalPrice_swiginit, METH_VARARGS, NULL},
	 { "IndexManager_instance", _wrap_IndexManager_instance, METH_NOARGS, "IndexManager_instance() -> IndexManager"},
	 { "IndexManager_setHistory", _wrap_IndexManager_setHistory, METH_VARARGS, "IndexManager_setHistory(IndexManager self, std::string const & name, RealTimeSeries fixings)"},
	 { "IndexManager_getHistory", _wrap_IndexManager_getHistory, METH_VARARGS, "IndexManager_getHistory(IndexManager self, std::string const & name) -> RealTimeSeries"},
	 { "IndexManager_hasHistory", _wrap_IndexManager_hasHistory, METH_VARARGS, "IndexManager_hasHistory(IndexManager self, std::string const & name) -> bool"},
	 { "IndexManager_histories", _wrap_IndexManager_histories, METH_O, "IndexManager_histories(IndexManager self) -> StrVector"},
	 { "IndexManager_clearHistory", _wrap_IndexManager_clearHistory, METH_VARARGS, "IndexManager_clearHistory(IndexManager self, std::string const & name)"},
	 { "IndexManager_clearHistories", _wrap_IndexManager_clearHistories, METH_O, "IndexManager_clearHistories(IndexManager self)"},
	 { "IndexManager_hasHistoricalFixing", _wrap_IndexManager_hasHistoricalFixing, METH_VARARGS, "IndexManager_hasHistoricalFixing(IndexManager self, std::string const & name, Date fixingDate) -> bool"},
	 { "delete_IndexManager", _wrap_delete_IndexManager, METH_O, "delete_IndexManager(IndexManager self)"},
	 { "IndexManager_swigregister", IndexManager_swigregister, METH_O, NULL},
	 { "Index_name", _wrap_Index_name, METH_O, "Index_name(Index self) -> std::string"},
	 { "Index_fixingCalendar", _wrap_Index_fixingCalendar, METH_O, "Index_fixingCalendar(Index self) -> Calendar"},
	 { "Index_isValidFixingDate", _wrap_Index_isValidFixingDate, METH_VARARGS, "Index_isValidFixingDate(Index self, Date fixingDate) -> bool"},
	 { "Index_hasHistoricalFixing", _wrap_Index_hasHistoricalFixing, METH_VARARGS, "Index_hasHistoricalFixing(Index self, Date fixingDate) -> bool"},
	 { "Index_fixing", _wrap_Index_fixing, METH_VARARGS, "Index_fixing(Index self, Date fixingDate, bool forecastTodaysFixing=False) -> Real"},
	 { "Index_addFixing", _wrap_Index_addFixing, METH_VARARGS, "Index_addFixing(Index self, Date fixingDate, Rate fixing, bool forceOverwrite=False)"},
	 { "Index_timeSeries", _wrap_Index_timeSeries, METH_O, "Index_timeSeries(Index self) -> RealTimeSeries"},
	 { "Index_clearFixings", _wrap_Index_clearFixings, METH_O, "Index_clearFixings(Index self)"},
	 { "Index_addFixings", _wrap_Index_addFixings, METH_VARARGS, "Index_addFixings(Index self, DateVector fixingDates, DoubleVector fixings, bool forceOverwrite=False)"},
	 { "Index___str__", _wrap_Index___str__, METH_O, "Index___str__(Index self) -> std::string"},
	 { "delete_Index", _wrap_delete_Index, METH_O, "delete_Index(Index self)"},
	 { "Index_swigregister", Index_swigregister, METH_O, NULL},
	 { "InterestRateIndex_familyName", _wrap_InterestRateIndex_familyName, METH_O, "InterestRateIndex_familyName(InterestRateIndex self) -> std::string"},
	 { "InterestRateIndex_tenor", _wrap_InterestRateIndex_tenor, METH_O, "InterestRateIndex_tenor(InterestRateIndex self) -> Period"},
	 { "InterestRateIndex_fixingDays", _wrap_InterestRateIndex_fixingDays, METH_O, "InterestRateIndex_fixingDays(InterestRateIndex self) -> Natural"},
	 { "InterestRateIndex_fixingDate", _wrap_InterestRateIndex_fixingDate, METH_VARARGS, "InterestRateIndex_fixingDate(InterestRateIndex self, Date valueDate) -> Date"},
	 { "InterestRateIndex_currency", _wrap_InterestRateIndex_currency, METH_O, "InterestRateIndex_currency(InterestRateIndex self) -> Currency"},
	 { "InterestRateIndex_dayCounter", _wrap_InterestRateIndex_dayCounter, METH_O, "InterestRateIndex_dayCounter(InterestRateIndex self) -> DayCounter"},
	 { "InterestRateIndex_maturityDate", _wrap_InterestRateIndex_maturityDate, METH_VARARGS, "InterestRateIndex_maturityDate(InterestRateIndex self, Date valueDate) -> Date"},
	 { "InterestRateIndex_valueDate", _wrap_InterestRateIndex_valueDate, METH_VARARGS, "InterestRateIndex_valueDate(InterestRateIndex self, Date fixingDate) -> Date"},
	 { "delete_InterestRateIndex", _wrap_delete_InterestRateIndex, METH_O, "delete_InterestRateIndex(InterestRateIndex self)"},
	 { "InterestRateIndex_swigregister", InterestRateIndex_swigregister, METH_O, NULL},
	 { "new_IborIndex", _wrap_new_IborIndex, METH_VARARGS, "IborIndex(std::string const & familyName, Period tenor, Integer settlementDays, Currency currency, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "IborIndex_businessDayConvention", _wrap_IborIndex_businessDayConvention, METH_O, "IborIndex_businessDayConvention(IborIndex self) -> BusinessDayConvention"},
	 { "IborIndex_endOfMonth", _wrap_IborIndex_endOfMonth, METH_O, "IborIndex_endOfMonth(IborIndex self) -> bool"},
	 { "IborIndex_forwardingTermStructure", _wrap_IborIndex_forwardingTermStructure, METH_O, "IborIndex_forwardingTermStructure(IborIndex self) -> YieldTermStructureHandle"},
	 { "IborIndex_clone", _wrap_IborIndex_clone, METH_VARARGS, "IborIndex_clone(IborIndex self, YieldTermStructureHandle arg2) -> ext::shared_ptr< IborIndex >"},
	 { "delete_IborIndex", _wrap_delete_IborIndex, METH_O, "delete_IborIndex(IborIndex self)"},
	 { "IborIndex_swigregister", IborIndex_swigregister, METH_O, NULL},
	 { "IborIndex_swiginit", IborIndex_swiginit, METH_VARARGS, NULL},
	 { "as_iborindex", _wrap_as_iborindex, METH_O, "as_iborindex(ext::shared_ptr< InterestRateIndex > const & index) -> ext::shared_ptr< IborIndex >"},
	 { "new_OvernightIndex", _wrap_new_OvernightIndex, METH_VARARGS, "OvernightIndex(std::string const & familyName, Integer settlementDays, Currency currency, Calendar calendar, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "OvernightIndex_clone", _wrap_OvernightIndex_clone, METH_VARARGS, "OvernightIndex_clone(OvernightIndex self, YieldTermStructureHandle h) -> ext::shared_ptr< OvernightIndex >"},
	 { "delete_OvernightIndex", _wrap_delete_OvernightIndex, METH_O, "delete_OvernightIndex(OvernightIndex self)"},
	 { "OvernightIndex_swigregister", OvernightIndex_swigregister, METH_O, NULL},
	 { "OvernightIndex_swiginit", OvernightIndex_swiginit, METH_VARARGS, NULL},
	 { "new_Libor", _wrap_new_Libor, METH_VARARGS, "Libor(std::string const & familyName, Period tenor, Natural settlementDays, Currency currency, Calendar financialCenterCalendar, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Libor", _wrap_delete_Libor, METH_O, "delete_Libor(Libor self)"},
	 { "Libor_swigregister", Libor_swigregister, METH_O, NULL},
	 { "Libor_swiginit", Libor_swiginit, METH_VARARGS, NULL},
	 { "new_DailyTenorLibor", _wrap_new_DailyTenorLibor, METH_VARARGS, "DailyTenorLibor(std::string const & familyName, Natural settlementDays, Currency currency, Calendar financialCenterCalendar, DayCounter dayCounter, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_DailyTenorLibor", _wrap_delete_DailyTenorLibor, METH_O, "delete_DailyTenorLibor(DailyTenorLibor self)"},
	 { "DailyTenorLibor_swigregister", DailyTenorLibor_swigregister, METH_O, NULL},
	 { "DailyTenorLibor_swiginit", DailyTenorLibor_swiginit, METH_VARARGS, NULL},
	 { "new_SwapIndex", _wrap_new_SwapIndex, METH_VARARGS, "\n"
		"SwapIndex(std::string const & familyName, Period tenor, Integer settlementDays, Currency currency, Calendar calendar, Period fixedLegTenor, BusinessDayConvention fixedLegConvention, DayCounter fixedLegDayCounter, ext::shared_ptr< IborIndex > const & iborIndex)\n"
		"new_SwapIndex(std::string const & familyName, Period tenor, Integer settlementDays, Currency currency, Calendar calendar, Period fixedLegTenor, BusinessDayConvention fixedLegConvention, DayCounter fixedLegDayCounter, ext::shared_ptr< IborIndex > const & iborIndex, YieldTermStructureHandle discountCurve) -> SwapIndex\n"
		""},
	 { "SwapIndex_fixedLegTenor", _wrap_SwapIndex_fixedLegTenor, METH_O, "SwapIndex_fixedLegTenor(SwapIndex self) -> Period"},
	 { "SwapIndex_fixedLegConvention", _wrap_SwapIndex_fixedLegConvention, METH_O, "SwapIndex_fixedLegConvention(SwapIndex self) -> BusinessDayConvention"},
	 { "SwapIndex_iborIndex", _wrap_SwapIndex_iborIndex, METH_O, "SwapIndex_iborIndex(SwapIndex self) -> ext::shared_ptr< IborIndex >"},
	 { "SwapIndex_forwardingTermStructure", _wrap_SwapIndex_forwardingTermStructure, METH_O, "SwapIndex_forwardingTermStructure(SwapIndex self) -> YieldTermStructureHandle"},
	 { "SwapIndex_discountingTermStructure", _wrap_SwapIndex_discountingTermStructure, METH_O, "SwapIndex_discountingTermStructure(SwapIndex self) -> YieldTermStructureHandle"},
	 { "SwapIndex_clone", _wrap_SwapIndex_clone, METH_VARARGS, "\n"
		"SwapIndex_clone(SwapIndex self, YieldTermStructureHandle h) -> ext::shared_ptr< SwapIndex >\n"
		"SwapIndex_clone(SwapIndex self, YieldTermStructureHandle forwarding, YieldTermStructureHandle discounting) -> ext::shared_ptr< SwapIndex >\n"
		"SwapIndex_clone(SwapIndex self, Period tenor) -> ext::shared_ptr< SwapIndex >\n"
		""},
	 { "delete_SwapIndex", _wrap_delete_SwapIndex, METH_O, "delete_SwapIndex(SwapIndex self)"},
	 { "SwapIndex_swigregister", SwapIndex_swigregister, METH_O, NULL},
	 { "SwapIndex_swiginit", SwapIndex_swiginit, METH_VARARGS, NULL},
	 { "SwapIndexVector_iterator", _wrap_SwapIndexVector_iterator, METH_O, "SwapIndexVector_iterator(SwapIndexVector self) -> SwigPyIterator"},
	 { "SwapIndexVector___nonzero__", _wrap_SwapIndexVector___nonzero__, METH_O, "SwapIndexVector___nonzero__(SwapIndexVector self) -> bool"},
	 { "SwapIndexVector___bool__", _wrap_SwapIndexVector___bool__, METH_O, "SwapIndexVector___bool__(SwapIndexVector self) -> bool"},
	 { "SwapIndexVector___len__", _wrap_SwapIndexVector___len__, METH_O, "SwapIndexVector___len__(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::size_type"},
	 { "SwapIndexVector___getslice__", _wrap_SwapIndexVector___getslice__, METH_VARARGS, "SwapIndexVector___getslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j) -> SwapIndexVector"},
	 { "SwapIndexVector___setslice__", _wrap_SwapIndexVector___setslice__, METH_VARARGS, "\n"
		"SwapIndexVector___setslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j)\n"
		"SwapIndexVector___setslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j, SwapIndexVector v)\n"
		""},
	 { "SwapIndexVector___delslice__", _wrap_SwapIndexVector___delslice__, METH_VARARGS, "SwapIndexVector___delslice__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::difference_type j)"},
	 { "SwapIndexVector___delitem__", _wrap_SwapIndexVector___delitem__, METH_VARARGS, "\n"
		"SwapIndexVector___delitem__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i)\n"
		"SwapIndexVector___delitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "SwapIndexVector___getitem__", _wrap_SwapIndexVector___getitem__, METH_VARARGS, "\n"
		"SwapIndexVector___getitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice) -> SwapIndexVector\n"
		"SwapIndexVector___getitem__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type const &\n"
		""},
	 { "SwapIndexVector___setitem__", _wrap_SwapIndexVector___setitem__, METH_VARARGS, "\n"
		"SwapIndexVector___setitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice, SwapIndexVector v)\n"
		"SwapIndexVector___setitem__(SwapIndexVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"SwapIndexVector___setitem__(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::difference_type i, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)\n"
		""},
	 { "SwapIndexVector_pop", _wrap_SwapIndexVector_pop, METH_O, "SwapIndexVector_pop(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type"},
	 { "SwapIndexVector_append", _wrap_SwapIndexVector_append, METH_VARARGS, "SwapIndexVector_append(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)"},
	 { "SwapIndexVector_empty", _wrap_SwapIndexVector_empty, METH_O, "SwapIndexVector_empty(SwapIndexVector self) -> bool"},
	 { "SwapIndexVector_size", _wrap_SwapIndexVector_size, METH_O, "SwapIndexVector_size(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::size_type"},
	 { "SwapIndexVector_swap", _wrap_SwapIndexVector_swap, METH_VARARGS, "SwapIndexVector_swap(SwapIndexVector self, SwapIndexVector v)"},
	 { "SwapIndexVector_begin", _wrap_SwapIndexVector_begin, METH_O, "SwapIndexVector_begin(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator"},
	 { "SwapIndexVector_end", _wrap_SwapIndexVector_end, METH_O, "SwapIndexVector_end(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator"},
	 { "SwapIndexVector_rbegin", _wrap_SwapIndexVector_rbegin, METH_O, "SwapIndexVector_rbegin(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator"},
	 { "SwapIndexVector_rend", _wrap_SwapIndexVector_rend, METH_O, "SwapIndexVector_rend(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::reverse_iterator"},
	 { "SwapIndexVector_clear", _wrap_SwapIndexVector_clear, METH_O, "SwapIndexVector_clear(SwapIndexVector self)"},
	 { "SwapIndexVector_get_allocator", _wrap_SwapIndexVector_get_allocator, METH_O, "SwapIndexVector_get_allocator(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::allocator_type"},
	 { "SwapIndexVector_pop_back", _wrap_SwapIndexVector_pop_back, METH_O, "SwapIndexVector_pop_back(SwapIndexVector self)"},
	 { "SwapIndexVector_erase", _wrap_SwapIndexVector_erase, METH_VARARGS, "\n"
		"SwapIndexVector_erase(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator pos) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator\n"
		"SwapIndexVector_erase(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator first, std::vector< ext::shared_ptr< SwapIndex > >::iterator last) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator\n"
		""},
	 { "new_SwapIndexVector", _wrap_new_SwapIndexVector, METH_VARARGS, "\n"
		"SwapIndexVector()\n"
		"SwapIndexVector(SwapIndexVector other)\n"
		"SwapIndexVector(std::vector< ext::shared_ptr< SwapIndex > >::size_type size)\n"
		"new_SwapIndexVector(std::vector< ext::shared_ptr< SwapIndex > >::size_type size, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & value) -> SwapIndexVector\n"
		""},
	 { "SwapIndexVector_push_back", _wrap_SwapIndexVector_push_back, METH_VARARGS, "SwapIndexVector_push_back(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)"},
	 { "SwapIndexVector_front", _wrap_SwapIndexVector_front, METH_O, "SwapIndexVector_front(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type const &"},
	 { "SwapIndexVector_back", _wrap_SwapIndexVector_back, METH_O, "SwapIndexVector_back(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::value_type const &"},
	 { "SwapIndexVector_assign", _wrap_SwapIndexVector_assign, METH_VARARGS, "SwapIndexVector_assign(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type n, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)"},
	 { "SwapIndexVector_resize", _wrap_SwapIndexVector_resize, METH_VARARGS, "\n"
		"SwapIndexVector_resize(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type new_size)\n"
		"SwapIndexVector_resize(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type new_size, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)\n"
		""},
	 { "SwapIndexVector_insert", _wrap_SwapIndexVector_insert, METH_VARARGS, "\n"
		"SwapIndexVector_insert(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator pos, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x) -> std::vector< ext::shared_ptr< SwapIndex > >::iterator\n"
		"SwapIndexVector_insert(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::iterator pos, std::vector< ext::shared_ptr< SwapIndex > >::size_type n, std::vector< ext::shared_ptr< SwapIndex > >::value_type const & x)\n"
		""},
	 { "SwapIndexVector_reserve", _wrap_SwapIndexVector_reserve, METH_VARARGS, "SwapIndexVector_reserve(SwapIndexVector self, std::vector< ext::shared_ptr< SwapIndex > >::size_type n)"},
	 { "SwapIndexVector_capacity", _wrap_SwapIndexVector_capacity, METH_O, "SwapIndexVector_capacity(SwapIndexVector self) -> std::vector< ext::shared_ptr< SwapIndex > >::size_type"},
	 { "delete_SwapIndexVector", _wrap_delete_SwapIndexVector, METH_O, "delete_SwapIndexVector(SwapIndexVector self)"},
	 { "SwapIndexVector_swigregister", SwapIndexVector_swigregister, METH_O, NULL},
	 { "SwapIndexVector_swiginit", SwapIndexVector_swiginit, METH_VARARGS, NULL},
	 { "as_swap_index", _wrap_as_swap_index, METH_O, "as_swap_index(ext::shared_ptr< InterestRateIndex > const & index) -> ext::shared_ptr< SwapIndex >"},
	 { "new_SwapSpreadIndex", _wrap_new_SwapSpreadIndex, METH_VARARGS, "SwapSpreadIndex(std::string const & familyName, ext::shared_ptr< SwapIndex > const & swapIndex1, ext::shared_ptr< SwapIndex > const & swapIndex2, Real const gearing1=1.0, Real const gearing2=-1.0)"},
	 { "SwapSpreadIndex_forecastFixing", _wrap_SwapSpreadIndex_forecastFixing, METH_VARARGS, "SwapSpreadIndex_forecastFixing(SwapSpreadIndex self, Date fixingDate) -> Rate"},
	 { "SwapSpreadIndex_pastFixing", _wrap_SwapSpreadIndex_pastFixing, METH_VARARGS, "SwapSpreadIndex_pastFixing(SwapSpreadIndex self, Date fixingDate) -> Rate"},
	 { "SwapSpreadIndex_swapIndex1", _wrap_SwapSpreadIndex_swapIndex1, METH_O, "SwapSpreadIndex_swapIndex1(SwapSpreadIndex self) -> ext::shared_ptr< SwapIndex >"},
	 { "SwapSpreadIndex_swapIndex2", _wrap_SwapSpreadIndex_swapIndex2, METH_O, "SwapSpreadIndex_swapIndex2(SwapSpreadIndex self) -> ext::shared_ptr< SwapIndex >"},
	 { "SwapSpreadIndex_gearing1", _wrap_SwapSpreadIndex_gearing1, METH_O, "SwapSpreadIndex_gearing1(SwapSpreadIndex self) -> Real"},
	 { "SwapSpreadIndex_gearing2", _wrap_SwapSpreadIndex_gearing2, METH_O, "SwapSpreadIndex_gearing2(SwapSpreadIndex self) -> Real"},
	 { "delete_SwapSpreadIndex", _wrap_delete_SwapSpreadIndex, METH_O, "delete_SwapSpreadIndex(SwapSpreadIndex self)"},
	 { "SwapSpreadIndex_swigregister", SwapSpreadIndex_swigregister, METH_O, NULL},
	 { "SwapSpreadIndex_swiginit", SwapSpreadIndex_swiginit, METH_VARARGS, NULL},
	 { "new_EquityIndex", _wrap_new_EquityIndex, METH_VARARGS, "EquityIndex(std::string name, Calendar fixingCalendar, YieldTermStructureHandle interest={}, YieldTermStructureHandle dividend={}, QuoteHandle spot={})"},
	 { "EquityIndex_equityInterestRateCurve", _wrap_EquityIndex_equityInterestRateCurve, METH_O, "EquityIndex_equityInterestRateCurve(EquityIndex self) -> YieldTermStructureHandle"},
	 { "EquityIndex_equityDividendCurve", _wrap_EquityIndex_equityDividendCurve, METH_O, "EquityIndex_equityDividendCurve(EquityIndex self) -> YieldTermStructureHandle"},
	 { "EquityIndex_spot", _wrap_EquityIndex_spot, METH_O, "EquityIndex_spot(EquityIndex self) -> QuoteHandle"},
	 { "EquityIndex_clone", _wrap_EquityIndex_clone, METH_VARARGS, "EquityIndex_clone(EquityIndex self, YieldTermStructureHandle interest, YieldTermStructureHandle dividend, QuoteHandle spot) -> ext::shared_ptr< EquityIndex >"},
	 { "delete_EquityIndex", _wrap_delete_EquityIndex, METH_O, "delete_EquityIndex(EquityIndex self)"},
	 { "EquityIndex_swigregister", EquityIndex_swigregister, METH_O, NULL},
	 { "EquityIndex_swiginit", EquityIndex_swiginit, METH_VARARGS, NULL},
	 { "new_AUDLibor", _wrap_new_AUDLibor, METH_VARARGS, "AUDLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_AUDLibor", _wrap_delete_AUDLibor, METH_O, "delete_AUDLibor(AUDLibor self)"},
	 { "AUDLibor_swigregister", AUDLibor_swigregister, METH_O, NULL},
	 { "AUDLibor_swiginit", AUDLibor_swiginit, METH_VARARGS, NULL},
	 { "new_CADLibor", _wrap_new_CADLibor, METH_VARARGS, "CADLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_CADLibor", _wrap_delete_CADLibor, METH_O, "delete_CADLibor(CADLibor self)"},
	 { "CADLibor_swigregister", CADLibor_swigregister, METH_O, NULL},
	 { "CADLibor_swiginit", CADLibor_swiginit, METH_VARARGS, NULL},
	 { "new_CADLiborON", _wrap_new_CADLiborON, METH_VARARGS, "CADLiborON(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_CADLiborON", _wrap_delete_CADLiborON, METH_O, "delete_CADLiborON(CADLiborON self)"},
	 { "CADLiborON_swigregister", CADLiborON_swigregister, METH_O, NULL},
	 { "CADLiborON_swiginit", CADLiborON_swiginit, METH_VARARGS, NULL},
	 { "new_Cdor", _wrap_new_Cdor, METH_VARARGS, "Cdor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Cdor", _wrap_delete_Cdor, METH_O, "delete_Cdor(Cdor self)"},
	 { "Cdor_swigregister", Cdor_swigregister, METH_O, NULL},
	 { "Cdor_swiginit", Cdor_swiginit, METH_VARARGS, NULL},
	 { "new_CHFLibor", _wrap_new_CHFLibor, METH_VARARGS, "CHFLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_CHFLibor", _wrap_delete_CHFLibor, METH_O, "delete_CHFLibor(CHFLibor self)"},
	 { "CHFLibor_swigregister", CHFLibor_swigregister, METH_O, NULL},
	 { "CHFLibor_swiginit", CHFLibor_swiginit, METH_VARARGS, NULL},
	 { "new_DKKLibor", _wrap_new_DKKLibor, METH_VARARGS, "DKKLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_DKKLibor", _wrap_delete_DKKLibor, METH_O, "delete_DKKLibor(DKKLibor self)"},
	 { "DKKLibor_swigregister", DKKLibor_swigregister, METH_O, NULL},
	 { "DKKLibor_swiginit", DKKLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw", _wrap_new_Bbsw, METH_VARARGS, "Bbsw(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw", _wrap_delete_Bbsw, METH_O, "delete_Bbsw(Bbsw self)"},
	 { "Bbsw_swigregister", Bbsw_swigregister, METH_O, NULL},
	 { "Bbsw_swiginit", Bbsw_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw1M", _wrap_new_Bbsw1M, METH_VARARGS, "Bbsw1M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw1M", _wrap_delete_Bbsw1M, METH_O, "delete_Bbsw1M(Bbsw1M self)"},
	 { "Bbsw1M_swigregister", Bbsw1M_swigregister, METH_O, NULL},
	 { "Bbsw1M_swiginit", Bbsw1M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw2M", _wrap_new_Bbsw2M, METH_VARARGS, "Bbsw2M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw2M", _wrap_delete_Bbsw2M, METH_O, "delete_Bbsw2M(Bbsw2M self)"},
	 { "Bbsw2M_swigregister", Bbsw2M_swigregister, METH_O, NULL},
	 { "Bbsw2M_swiginit", Bbsw2M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw3M", _wrap_new_Bbsw3M, METH_VARARGS, "Bbsw3M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw3M", _wrap_delete_Bbsw3M, METH_O, "delete_Bbsw3M(Bbsw3M self)"},
	 { "Bbsw3M_swigregister", Bbsw3M_swigregister, METH_O, NULL},
	 { "Bbsw3M_swiginit", Bbsw3M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw4M", _wrap_new_Bbsw4M, METH_VARARGS, "Bbsw4M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw4M", _wrap_delete_Bbsw4M, METH_O, "delete_Bbsw4M(Bbsw4M self)"},
	 { "Bbsw4M_swigregister", Bbsw4M_swigregister, METH_O, NULL},
	 { "Bbsw4M_swiginit", Bbsw4M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw5M", _wrap_new_Bbsw5M, METH_VARARGS, "Bbsw5M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw5M", _wrap_delete_Bbsw5M, METH_O, "delete_Bbsw5M(Bbsw5M self)"},
	 { "Bbsw5M_swigregister", Bbsw5M_swigregister, METH_O, NULL},
	 { "Bbsw5M_swiginit", Bbsw5M_swiginit, METH_VARARGS, NULL},
	 { "new_Bbsw6M", _wrap_new_Bbsw6M, METH_VARARGS, "Bbsw6M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bbsw6M", _wrap_delete_Bbsw6M, METH_O, "delete_Bbsw6M(Bbsw6M self)"},
	 { "Bbsw6M_swigregister", Bbsw6M_swigregister, METH_O, NULL},
	 { "Bbsw6M_swiginit", Bbsw6M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm", _wrap_new_Bkbm, METH_VARARGS, "Bkbm(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm", _wrap_delete_Bkbm, METH_O, "delete_Bkbm(Bkbm self)"},
	 { "Bkbm_swigregister", Bkbm_swigregister, METH_O, NULL},
	 { "Bkbm_swiginit", Bkbm_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm1M", _wrap_new_Bkbm1M, METH_VARARGS, "Bkbm1M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm1M", _wrap_delete_Bkbm1M, METH_O, "delete_Bkbm1M(Bkbm1M self)"},
	 { "Bkbm1M_swigregister", Bkbm1M_swigregister, METH_O, NULL},
	 { "Bkbm1M_swiginit", Bkbm1M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm2M", _wrap_new_Bkbm2M, METH_VARARGS, "Bkbm2M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm2M", _wrap_delete_Bkbm2M, METH_O, "delete_Bkbm2M(Bkbm2M self)"},
	 { "Bkbm2M_swigregister", Bkbm2M_swigregister, METH_O, NULL},
	 { "Bkbm2M_swiginit", Bkbm2M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm3M", _wrap_new_Bkbm3M, METH_VARARGS, "Bkbm3M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm3M", _wrap_delete_Bkbm3M, METH_O, "delete_Bkbm3M(Bkbm3M self)"},
	 { "Bkbm3M_swigregister", Bkbm3M_swigregister, METH_O, NULL},
	 { "Bkbm3M_swiginit", Bkbm3M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm4M", _wrap_new_Bkbm4M, METH_VARARGS, "Bkbm4M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm4M", _wrap_delete_Bkbm4M, METH_O, "delete_Bkbm4M(Bkbm4M self)"},
	 { "Bkbm4M_swigregister", Bkbm4M_swigregister, METH_O, NULL},
	 { "Bkbm4M_swiginit", Bkbm4M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm5M", _wrap_new_Bkbm5M, METH_VARARGS, "Bkbm5M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm5M", _wrap_delete_Bkbm5M, METH_O, "delete_Bkbm5M(Bkbm5M self)"},
	 { "Bkbm5M_swigregister", Bkbm5M_swigregister, METH_O, NULL},
	 { "Bkbm5M_swiginit", Bkbm5M_swiginit, METH_VARARGS, NULL},
	 { "new_Bkbm6M", _wrap_new_Bkbm6M, METH_VARARGS, "Bkbm6M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bkbm6M", _wrap_delete_Bkbm6M, METH_O, "delete_Bkbm6M(Bkbm6M self)"},
	 { "Bkbm6M_swigregister", Bkbm6M_swigregister, METH_O, NULL},
	 { "Bkbm6M_swiginit", Bkbm6M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor", _wrap_new_Euribor, METH_VARARGS, "Euribor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor", _wrap_delete_Euribor, METH_O, "delete_Euribor(Euribor self)"},
	 { "Euribor_swigregister", Euribor_swigregister, METH_O, NULL},
	 { "Euribor_swiginit", Euribor_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSW", _wrap_new_EuriborSW, METH_VARARGS, "EuriborSW(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EuriborSW", _wrap_delete_EuriborSW, METH_O, "delete_EuriborSW(EuriborSW self)"},
	 { "EuriborSW_swigregister", EuriborSW_swigregister, METH_O, NULL},
	 { "EuriborSW_swiginit", EuriborSW_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor2W", _wrap_new_Euribor2W, METH_VARARGS, "Euribor2W(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor2W", _wrap_delete_Euribor2W, METH_O, "delete_Euribor2W(Euribor2W self)"},
	 { "Euribor2W_swigregister", Euribor2W_swigregister, METH_O, NULL},
	 { "Euribor2W_swiginit", Euribor2W_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor3W", _wrap_new_Euribor3W, METH_VARARGS, "Euribor3W(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor3W", _wrap_delete_Euribor3W, METH_O, "delete_Euribor3W(Euribor3W self)"},
	 { "Euribor3W_swigregister", Euribor3W_swigregister, METH_O, NULL},
	 { "Euribor3W_swiginit", Euribor3W_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor1M", _wrap_new_Euribor1M, METH_VARARGS, "Euribor1M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor1M", _wrap_delete_Euribor1M, METH_O, "delete_Euribor1M(Euribor1M self)"},
	 { "Euribor1M_swigregister", Euribor1M_swigregister, METH_O, NULL},
	 { "Euribor1M_swiginit", Euribor1M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor2M", _wrap_new_Euribor2M, METH_VARARGS, "Euribor2M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor2M", _wrap_delete_Euribor2M, METH_O, "delete_Euribor2M(Euribor2M self)"},
	 { "Euribor2M_swigregister", Euribor2M_swigregister, METH_O, NULL},
	 { "Euribor2M_swiginit", Euribor2M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor3M", _wrap_new_Euribor3M, METH_VARARGS, "Euribor3M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor3M", _wrap_delete_Euribor3M, METH_O, "delete_Euribor3M(Euribor3M self)"},
	 { "Euribor3M_swigregister", Euribor3M_swigregister, METH_O, NULL},
	 { "Euribor3M_swiginit", Euribor3M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor4M", _wrap_new_Euribor4M, METH_VARARGS, "Euribor4M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor4M", _wrap_delete_Euribor4M, METH_O, "delete_Euribor4M(Euribor4M self)"},
	 { "Euribor4M_swigregister", Euribor4M_swigregister, METH_O, NULL},
	 { "Euribor4M_swiginit", Euribor4M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor5M", _wrap_new_Euribor5M, METH_VARARGS, "Euribor5M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor5M", _wrap_delete_Euribor5M, METH_O, "delete_Euribor5M(Euribor5M self)"},
	 { "Euribor5M_swigregister", Euribor5M_swigregister, METH_O, NULL},
	 { "Euribor5M_swiginit", Euribor5M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor6M", _wrap_new_Euribor6M, METH_VARARGS, "Euribor6M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor6M", _wrap_delete_Euribor6M, METH_O, "delete_Euribor6M(Euribor6M self)"},
	 { "Euribor6M_swigregister", Euribor6M_swigregister, METH_O, NULL},
	 { "Euribor6M_swiginit", Euribor6M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor7M", _wrap_new_Euribor7M, METH_VARARGS, "Euribor7M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor7M", _wrap_delete_Euribor7M, METH_O, "delete_Euribor7M(Euribor7M self)"},
	 { "Euribor7M_swigregister", Euribor7M_swigregister, METH_O, NULL},
	 { "Euribor7M_swiginit", Euribor7M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor8M", _wrap_new_Euribor8M, METH_VARARGS, "Euribor8M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor8M", _wrap_delete_Euribor8M, METH_O, "delete_Euribor8M(Euribor8M self)"},
	 { "Euribor8M_swigregister", Euribor8M_swigregister, METH_O, NULL},
	 { "Euribor8M_swiginit", Euribor8M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor9M", _wrap_new_Euribor9M, METH_VARARGS, "Euribor9M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor9M", _wrap_delete_Euribor9M, METH_O, "delete_Euribor9M(Euribor9M self)"},
	 { "Euribor9M_swigregister", Euribor9M_swigregister, METH_O, NULL},
	 { "Euribor9M_swiginit", Euribor9M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor10M", _wrap_new_Euribor10M, METH_VARARGS, "Euribor10M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor10M", _wrap_delete_Euribor10M, METH_O, "delete_Euribor10M(Euribor10M self)"},
	 { "Euribor10M_swigregister", Euribor10M_swigregister, METH_O, NULL},
	 { "Euribor10M_swiginit", Euribor10M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor11M", _wrap_new_Euribor11M, METH_VARARGS, "Euribor11M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor11M", _wrap_delete_Euribor11M, METH_O, "delete_Euribor11M(Euribor11M self)"},
	 { "Euribor11M_swigregister", Euribor11M_swigregister, METH_O, NULL},
	 { "Euribor11M_swiginit", Euribor11M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor1Y", _wrap_new_Euribor1Y, METH_VARARGS, "Euribor1Y(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor1Y", _wrap_delete_Euribor1Y, METH_O, "delete_Euribor1Y(Euribor1Y self)"},
	 { "Euribor1Y_swigregister", Euribor1Y_swigregister, METH_O, NULL},
	 { "Euribor1Y_swiginit", Euribor1Y_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365", _wrap_new_Euribor365, METH_VARARGS, "Euribor365(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365", _wrap_delete_Euribor365, METH_O, "delete_Euribor365(Euribor365 self)"},
	 { "Euribor365_swigregister", Euribor365_swigregister, METH_O, NULL},
	 { "Euribor365_swiginit", Euribor365_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_SW", _wrap_new_Euribor365_SW, METH_VARARGS, "Euribor365_SW(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_SW", _wrap_delete_Euribor365_SW, METH_O, "delete_Euribor365_SW(Euribor365_SW self)"},
	 { "Euribor365_SW_swigregister", Euribor365_SW_swigregister, METH_O, NULL},
	 { "Euribor365_SW_swiginit", Euribor365_SW_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_2W", _wrap_new_Euribor365_2W, METH_VARARGS, "Euribor365_2W(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_2W", _wrap_delete_Euribor365_2W, METH_O, "delete_Euribor365_2W(Euribor365_2W self)"},
	 { "Euribor365_2W_swigregister", Euribor365_2W_swigregister, METH_O, NULL},
	 { "Euribor365_2W_swiginit", Euribor365_2W_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_3W", _wrap_new_Euribor365_3W, METH_VARARGS, "Euribor365_3W(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_3W", _wrap_delete_Euribor365_3W, METH_O, "delete_Euribor365_3W(Euribor365_3W self)"},
	 { "Euribor365_3W_swigregister", Euribor365_3W_swigregister, METH_O, NULL},
	 { "Euribor365_3W_swiginit", Euribor365_3W_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_1M", _wrap_new_Euribor365_1M, METH_VARARGS, "Euribor365_1M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_1M", _wrap_delete_Euribor365_1M, METH_O, "delete_Euribor365_1M(Euribor365_1M self)"},
	 { "Euribor365_1M_swigregister", Euribor365_1M_swigregister, METH_O, NULL},
	 { "Euribor365_1M_swiginit", Euribor365_1M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_2M", _wrap_new_Euribor365_2M, METH_VARARGS, "Euribor365_2M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_2M", _wrap_delete_Euribor365_2M, METH_O, "delete_Euribor365_2M(Euribor365_2M self)"},
	 { "Euribor365_2M_swigregister", Euribor365_2M_swigregister, METH_O, NULL},
	 { "Euribor365_2M_swiginit", Euribor365_2M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_3M", _wrap_new_Euribor365_3M, METH_VARARGS, "Euribor365_3M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_3M", _wrap_delete_Euribor365_3M, METH_O, "delete_Euribor365_3M(Euribor365_3M self)"},
	 { "Euribor365_3M_swigregister", Euribor365_3M_swigregister, METH_O, NULL},
	 { "Euribor365_3M_swiginit", Euribor365_3M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_4M", _wrap_new_Euribor365_4M, METH_VARARGS, "Euribor365_4M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_4M", _wrap_delete_Euribor365_4M, METH_O, "delete_Euribor365_4M(Euribor365_4M self)"},
	 { "Euribor365_4M_swigregister", Euribor365_4M_swigregister, METH_O, NULL},
	 { "Euribor365_4M_swiginit", Euribor365_4M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_5M", _wrap_new_Euribor365_5M, METH_VARARGS, "Euribor365_5M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_5M", _wrap_delete_Euribor365_5M, METH_O, "delete_Euribor365_5M(Euribor365_5M self)"},
	 { "Euribor365_5M_swigregister", Euribor365_5M_swigregister, METH_O, NULL},
	 { "Euribor365_5M_swiginit", Euribor365_5M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_6M", _wrap_new_Euribor365_6M, METH_VARARGS, "Euribor365_6M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_6M", _wrap_delete_Euribor365_6M, METH_O, "delete_Euribor365_6M(Euribor365_6M self)"},
	 { "Euribor365_6M_swigregister", Euribor365_6M_swigregister, METH_O, NULL},
	 { "Euribor365_6M_swiginit", Euribor365_6M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_7M", _wrap_new_Euribor365_7M, METH_VARARGS, "Euribor365_7M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_7M", _wrap_delete_Euribor365_7M, METH_O, "delete_Euribor365_7M(Euribor365_7M self)"},
	 { "Euribor365_7M_swigregister", Euribor365_7M_swigregister, METH_O, NULL},
	 { "Euribor365_7M_swiginit", Euribor365_7M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_8M", _wrap_new_Euribor365_8M, METH_VARARGS, "Euribor365_8M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_8M", _wrap_delete_Euribor365_8M, METH_O, "delete_Euribor365_8M(Euribor365_8M self)"},
	 { "Euribor365_8M_swigregister", Euribor365_8M_swigregister, METH_O, NULL},
	 { "Euribor365_8M_swiginit", Euribor365_8M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_9M", _wrap_new_Euribor365_9M, METH_VARARGS, "Euribor365_9M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_9M", _wrap_delete_Euribor365_9M, METH_O, "delete_Euribor365_9M(Euribor365_9M self)"},
	 { "Euribor365_9M_swigregister", Euribor365_9M_swigregister, METH_O, NULL},
	 { "Euribor365_9M_swiginit", Euribor365_9M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_10M", _wrap_new_Euribor365_10M, METH_VARARGS, "Euribor365_10M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_10M", _wrap_delete_Euribor365_10M, METH_O, "delete_Euribor365_10M(Euribor365_10M self)"},
	 { "Euribor365_10M_swigregister", Euribor365_10M_swigregister, METH_O, NULL},
	 { "Euribor365_10M_swiginit", Euribor365_10M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_11M", _wrap_new_Euribor365_11M, METH_VARARGS, "Euribor365_11M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_11M", _wrap_delete_Euribor365_11M, METH_O, "delete_Euribor365_11M(Euribor365_11M self)"},
	 { "Euribor365_11M_swigregister", Euribor365_11M_swigregister, METH_O, NULL},
	 { "Euribor365_11M_swiginit", Euribor365_11M_swiginit, METH_VARARGS, NULL},
	 { "new_Euribor365_1Y", _wrap_new_Euribor365_1Y, METH_VARARGS, "Euribor365_1Y(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Euribor365_1Y", _wrap_delete_Euribor365_1Y, METH_O, "delete_Euribor365_1Y(Euribor365_1Y self)"},
	 { "Euribor365_1Y_swigregister", Euribor365_1Y_swigregister, METH_O, NULL},
	 { "Euribor365_1Y_swiginit", Euribor365_1Y_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor", _wrap_new_EURLibor, METH_VARARGS, "EURLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor", _wrap_delete_EURLibor, METH_O, "delete_EURLibor(EURLibor self)"},
	 { "EURLibor_swigregister", EURLibor_swigregister, METH_O, NULL},
	 { "EURLibor_swiginit", EURLibor_swiginit, METH_VARARGS, NULL},
	 { "new_EURLiborSW", _wrap_new_EURLiborSW, METH_VARARGS, "EURLiborSW(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLiborSW", _wrap_delete_EURLiborSW, METH_O, "delete_EURLiborSW(EURLiborSW self)"},
	 { "EURLiborSW_swigregister", EURLiborSW_swigregister, METH_O, NULL},
	 { "EURLiborSW_swiginit", EURLiborSW_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor2W", _wrap_new_EURLibor2W, METH_VARARGS, "EURLibor2W(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor2W", _wrap_delete_EURLibor2W, METH_O, "delete_EURLibor2W(EURLibor2W self)"},
	 { "EURLibor2W_swigregister", EURLibor2W_swigregister, METH_O, NULL},
	 { "EURLibor2W_swiginit", EURLibor2W_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor1M", _wrap_new_EURLibor1M, METH_VARARGS, "EURLibor1M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor1M", _wrap_delete_EURLibor1M, METH_O, "delete_EURLibor1M(EURLibor1M self)"},
	 { "EURLibor1M_swigregister", EURLibor1M_swigregister, METH_O, NULL},
	 { "EURLibor1M_swiginit", EURLibor1M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor2M", _wrap_new_EURLibor2M, METH_VARARGS, "EURLibor2M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor2M", _wrap_delete_EURLibor2M, METH_O, "delete_EURLibor2M(EURLibor2M self)"},
	 { "EURLibor2M_swigregister", EURLibor2M_swigregister, METH_O, NULL},
	 { "EURLibor2M_swiginit", EURLibor2M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor3M", _wrap_new_EURLibor3M, METH_VARARGS, "EURLibor3M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor3M", _wrap_delete_EURLibor3M, METH_O, "delete_EURLibor3M(EURLibor3M self)"},
	 { "EURLibor3M_swigregister", EURLibor3M_swigregister, METH_O, NULL},
	 { "EURLibor3M_swiginit", EURLibor3M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor4M", _wrap_new_EURLibor4M, METH_VARARGS, "EURLibor4M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor4M", _wrap_delete_EURLibor4M, METH_O, "delete_EURLibor4M(EURLibor4M self)"},
	 { "EURLibor4M_swigregister", EURLibor4M_swigregister, METH_O, NULL},
	 { "EURLibor4M_swiginit", EURLibor4M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor5M", _wrap_new_EURLibor5M, METH_VARARGS, "EURLibor5M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor5M", _wrap_delete_EURLibor5M, METH_O, "delete_EURLibor5M(EURLibor5M self)"},
	 { "EURLibor5M_swigregister", EURLibor5M_swigregister, METH_O, NULL},
	 { "EURLibor5M_swiginit", EURLibor5M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor6M", _wrap_new_EURLibor6M, METH_VARARGS, "EURLibor6M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor6M", _wrap_delete_EURLibor6M, METH_O, "delete_EURLibor6M(EURLibor6M self)"},
	 { "EURLibor6M_swigregister", EURLibor6M_swigregister, METH_O, NULL},
	 { "EURLibor6M_swiginit", EURLibor6M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor7M", _wrap_new_EURLibor7M, METH_VARARGS, "EURLibor7M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor7M", _wrap_delete_EURLibor7M, METH_O, "delete_EURLibor7M(EURLibor7M self)"},
	 { "EURLibor7M_swigregister", EURLibor7M_swigregister, METH_O, NULL},
	 { "EURLibor7M_swiginit", EURLibor7M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor8M", _wrap_new_EURLibor8M, METH_VARARGS, "EURLibor8M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor8M", _wrap_delete_EURLibor8M, METH_O, "delete_EURLibor8M(EURLibor8M self)"},
	 { "EURLibor8M_swigregister", EURLibor8M_swigregister, METH_O, NULL},
	 { "EURLibor8M_swiginit", EURLibor8M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor9M", _wrap_new_EURLibor9M, METH_VARARGS, "EURLibor9M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor9M", _wrap_delete_EURLibor9M, METH_O, "delete_EURLibor9M(EURLibor9M self)"},
	 { "EURLibor9M_swigregister", EURLibor9M_swigregister, METH_O, NULL},
	 { "EURLibor9M_swiginit", EURLibor9M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor10M", _wrap_new_EURLibor10M, METH_VARARGS, "EURLibor10M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor10M", _wrap_delete_EURLibor10M, METH_O, "delete_EURLibor10M(EURLibor10M self)"},
	 { "EURLibor10M_swigregister", EURLibor10M_swigregister, METH_O, NULL},
	 { "EURLibor10M_swiginit", EURLibor10M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor11M", _wrap_new_EURLibor11M, METH_VARARGS, "EURLibor11M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor11M", _wrap_delete_EURLibor11M, METH_O, "delete_EURLibor11M(EURLibor11M self)"},
	 { "EURLibor11M_swigregister", EURLibor11M_swigregister, METH_O, NULL},
	 { "EURLibor11M_swiginit", EURLibor11M_swiginit, METH_VARARGS, NULL},
	 { "new_EURLibor1Y", _wrap_new_EURLibor1Y, METH_VARARGS, "EURLibor1Y(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_EURLibor1Y", _wrap_delete_EURLibor1Y, METH_O, "delete_EURLibor1Y(EURLibor1Y self)"},
	 { "EURLibor1Y_swigregister", EURLibor1Y_swigregister, METH_O, NULL},
	 { "EURLibor1Y_swiginit", EURLibor1Y_swiginit, METH_VARARGS, NULL},
	 { "new_GBPLibor", _wrap_new_GBPLibor, METH_VARARGS, "GBPLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_GBPLibor", _wrap_delete_GBPLibor, METH_O, "delete_GBPLibor(GBPLibor self)"},
	 { "GBPLibor_swigregister", GBPLibor_swigregister, METH_O, NULL},
	 { "GBPLibor_swiginit", GBPLibor_swiginit, METH_VARARGS, NULL},
	 { "new_GBPLiborON", _wrap_new_GBPLiborON, METH_VARARGS, "GBPLiborON(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_GBPLiborON", _wrap_delete_GBPLiborON, METH_O, "delete_GBPLiborON(GBPLiborON self)"},
	 { "GBPLiborON_swigregister", GBPLiborON_swigregister, METH_O, NULL},
	 { "GBPLiborON_swiginit", GBPLiborON_swiginit, METH_VARARGS, NULL},
	 { "new_Jibar", _wrap_new_Jibar, METH_VARARGS, "Jibar(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Jibar", _wrap_delete_Jibar, METH_O, "delete_Jibar(Jibar self)"},
	 { "Jibar_swigregister", Jibar_swigregister, METH_O, NULL},
	 { "Jibar_swiginit", Jibar_swiginit, METH_VARARGS, NULL},
	 { "new_JPYLibor", _wrap_new_JPYLibor, METH_VARARGS, "JPYLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_JPYLibor", _wrap_delete_JPYLibor, METH_O, "delete_JPYLibor(JPYLibor self)"},
	 { "JPYLibor_swigregister", JPYLibor_swigregister, METH_O, NULL},
	 { "JPYLibor_swiginit", JPYLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Mosprime", _wrap_new_Mosprime, METH_VARARGS, "Mosprime(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Mosprime", _wrap_delete_Mosprime, METH_O, "delete_Mosprime(Mosprime self)"},
	 { "Mosprime_swigregister", Mosprime_swigregister, METH_O, NULL},
	 { "Mosprime_swiginit", Mosprime_swiginit, METH_VARARGS, NULL},
	 { "new_NZDLibor", _wrap_new_NZDLibor, METH_VARARGS, "NZDLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_NZDLibor", _wrap_delete_NZDLibor, METH_O, "delete_NZDLibor(NZDLibor self)"},
	 { "NZDLibor_swigregister", NZDLibor_swigregister, METH_O, NULL},
	 { "NZDLibor_swiginit", NZDLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Pribor", _wrap_new_Pribor, METH_VARARGS, "Pribor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Pribor", _wrap_delete_Pribor, METH_O, "delete_Pribor(Pribor self)"},
	 { "Pribor_swigregister", Pribor_swigregister, METH_O, NULL},
	 { "Pribor_swiginit", Pribor_swiginit, METH_VARARGS, NULL},
	 { "new_Robor", _wrap_new_Robor, METH_VARARGS, "Robor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Robor", _wrap_delete_Robor, METH_O, "delete_Robor(Robor self)"},
	 { "Robor_swigregister", Robor_swigregister, METH_O, NULL},
	 { "Robor_swiginit", Robor_swiginit, METH_VARARGS, NULL},
	 { "new_SEKLibor", _wrap_new_SEKLibor, METH_VARARGS, "SEKLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_SEKLibor", _wrap_delete_SEKLibor, METH_O, "delete_SEKLibor(SEKLibor self)"},
	 { "SEKLibor_swigregister", SEKLibor_swigregister, METH_O, NULL},
	 { "SEKLibor_swiginit", SEKLibor_swiginit, METH_VARARGS, NULL},
	 { "new_Shibor", _wrap_new_Shibor, METH_VARARGS, "Shibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Shibor", _wrap_delete_Shibor, METH_O, "delete_Shibor(Shibor self)"},
	 { "Shibor_swigregister", Shibor_swigregister, METH_O, NULL},
	 { "Shibor_swiginit", Shibor_swiginit, METH_VARARGS, NULL},
	 { "new_Tibor", _wrap_new_Tibor, METH_VARARGS, "Tibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Tibor", _wrap_delete_Tibor, METH_O, "delete_Tibor(Tibor self)"},
	 { "Tibor_swigregister", Tibor_swigregister, METH_O, NULL},
	 { "Tibor_swiginit", Tibor_swiginit, METH_VARARGS, NULL},
	 { "new_THBFIX", _wrap_new_THBFIX, METH_VARARGS, "THBFIX(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_THBFIX", _wrap_delete_THBFIX, METH_O, "delete_THBFIX(THBFIX self)"},
	 { "THBFIX_swigregister", THBFIX_swigregister, METH_O, NULL},
	 { "THBFIX_swiginit", THBFIX_swiginit, METH_VARARGS, NULL},
	 { "new_TRLibor", _wrap_new_TRLibor, METH_VARARGS, "TRLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_TRLibor", _wrap_delete_TRLibor, METH_O, "delete_TRLibor(TRLibor self)"},
	 { "TRLibor_swigregister", TRLibor_swigregister, METH_O, NULL},
	 { "TRLibor_swiginit", TRLibor_swiginit, METH_VARARGS, NULL},
	 { "new_USDLibor", _wrap_new_USDLibor, METH_VARARGS, "USDLibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_USDLibor", _wrap_delete_USDLibor, METH_O, "delete_USDLibor(USDLibor self)"},
	 { "USDLibor_swigregister", USDLibor_swigregister, METH_O, NULL},
	 { "USDLibor_swiginit", USDLibor_swiginit, METH_VARARGS, NULL},
	 { "new_USDLiborON", _wrap_new_USDLiborON, METH_VARARGS, "USDLiborON(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_USDLiborON", _wrap_delete_USDLiborON, METH_O, "delete_USDLiborON(USDLiborON self)"},
	 { "USDLiborON_swigregister", USDLiborON_swigregister, METH_O, NULL},
	 { "USDLiborON_swiginit", USDLiborON_swiginit, METH_VARARGS, NULL},
	 { "new_Wibor", _wrap_new_Wibor, METH_VARARGS, "Wibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Wibor", _wrap_delete_Wibor, METH_O, "delete_Wibor(Wibor self)"},
	 { "Wibor_swigregister", Wibor_swigregister, METH_O, NULL},
	 { "Wibor_swiginit", Wibor_swiginit, METH_VARARGS, NULL},
	 { "new_Zibor", _wrap_new_Zibor, METH_VARARGS, "Zibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Zibor", _wrap_delete_Zibor, METH_O, "delete_Zibor(Zibor self)"},
	 { "Zibor_swigregister", Zibor_swigregister, METH_O, NULL},
	 { "Zibor_swiginit", Zibor_swiginit, METH_VARARGS, NULL},
	 { "new_Aonia", _wrap_new_Aonia, METH_VARARGS, "Aonia(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Aonia", _wrap_delete_Aonia, METH_O, "delete_Aonia(Aonia self)"},
	 { "Aonia_swigregister", Aonia_swigregister, METH_O, NULL},
	 { "Aonia_swiginit", Aonia_swiginit, METH_VARARGS, NULL},
	 { "new_Corra", _wrap_new_Corra, METH_VARARGS, "Corra(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Corra", _wrap_delete_Corra, METH_O, "delete_Corra(Corra self)"},
	 { "Corra_swigregister", Corra_swigregister, METH_O, NULL},
	 { "Corra_swiginit", Corra_swiginit, METH_VARARGS, NULL},
	 { "new_Destr", _wrap_new_Destr, METH_VARARGS, "Destr(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Destr", _wrap_delete_Destr, METH_O, "delete_Destr(Destr self)"},
	 { "Destr_swigregister", Destr_swigregister, METH_O, NULL},
	 { "Destr_swiginit", Destr_swiginit, METH_VARARGS, NULL},
	 { "new_Eonia", _wrap_new_Eonia, METH_VARARGS, "Eonia(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Eonia", _wrap_delete_Eonia, METH_O, "delete_Eonia(Eonia self)"},
	 { "Eonia_swigregister", Eonia_swigregister, METH_O, NULL},
	 { "Eonia_swiginit", Eonia_swiginit, METH_VARARGS, NULL},
	 { "new_Estr", _wrap_new_Estr, METH_VARARGS, "Estr(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Estr", _wrap_delete_Estr, METH_O, "delete_Estr(Estr self)"},
	 { "Estr_swigregister", Estr_swigregister, METH_O, NULL},
	 { "Estr_swiginit", Estr_swiginit, METH_VARARGS, NULL},
	 { "new_FedFunds", _wrap_new_FedFunds, METH_VARARGS, "FedFunds(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_FedFunds", _wrap_delete_FedFunds, METH_O, "delete_FedFunds(FedFunds self)"},
	 { "FedFunds_swigregister", FedFunds_swigregister, METH_O, NULL},
	 { "FedFunds_swiginit", FedFunds_swiginit, METH_VARARGS, NULL},
	 { "new_Nzocr", _wrap_new_Nzocr, METH_VARARGS, "Nzocr(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Nzocr", _wrap_delete_Nzocr, METH_O, "delete_Nzocr(Nzocr self)"},
	 { "Nzocr_swigregister", Nzocr_swigregister, METH_O, NULL},
	 { "Nzocr_swiginit", Nzocr_swiginit, METH_VARARGS, NULL},
	 { "new_Sofr", _wrap_new_Sofr, METH_VARARGS, "Sofr(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Sofr", _wrap_delete_Sofr, METH_O, "delete_Sofr(Sofr self)"},
	 { "Sofr_swigregister", Sofr_swigregister, METH_O, NULL},
	 { "Sofr_swiginit", Sofr_swiginit, METH_VARARGS, NULL},
	 { "new_Sonia", _wrap_new_Sonia, METH_VARARGS, "Sonia(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Sonia", _wrap_delete_Sonia, METH_O, "delete_Sonia(Sonia self)"},
	 { "Sonia_swigregister", Sonia_swigregister, METH_O, NULL},
	 { "Sonia_swiginit", Sonia_swiginit, METH_VARARGS, NULL},
	 { "new_Swestr", _wrap_new_Swestr, METH_VARARGS, "Swestr(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Swestr", _wrap_delete_Swestr, METH_O, "delete_Swestr(Swestr self)"},
	 { "Swestr_swigregister", Swestr_swigregister, METH_O, NULL},
	 { "Swestr_swiginit", Swestr_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSwapIsdaFixA", _wrap_new_EuriborSwapIsdaFixA, METH_VARARGS, "\n"
		"EuriborSwapIsdaFixA(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_EuriborSwapIsdaFixA(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EuriborSwapIsdaFixA\n"
		""},
	 { "delete_EuriborSwapIsdaFixA", _wrap_delete_EuriborSwapIsdaFixA, METH_O, "delete_EuriborSwapIsdaFixA(EuriborSwapIsdaFixA self)"},
	 { "EuriborSwapIsdaFixA_swigregister", EuriborSwapIsdaFixA_swigregister, METH_O, NULL},
	 { "EuriborSwapIsdaFixA_swiginit", EuriborSwapIsdaFixA_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSwapIsdaFixB", _wrap_new_EuriborSwapIsdaFixB, METH_VARARGS, "\n"
		"EuriborSwapIsdaFixB(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_EuriborSwapIsdaFixB(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EuriborSwapIsdaFixB\n"
		""},
	 { "delete_EuriborSwapIsdaFixB", _wrap_delete_EuriborSwapIsdaFixB, METH_O, "delete_EuriborSwapIsdaFixB(EuriborSwapIsdaFixB self)"},
	 { "EuriborSwapIsdaFixB_swigregister", EuriborSwapIsdaFixB_swigregister, METH_O, NULL},
	 { "EuriborSwapIsdaFixB_swiginit", EuriborSwapIsdaFixB_swiginit, METH_VARARGS, NULL},
	 { "new_EuriborSwapIfrFix", _wrap_new_EuriborSwapIfrFix, METH_VARARGS, "\n"
		"EuriborSwapIfrFix(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_EuriborSwapIfrFix(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EuriborSwapIfrFix\n"
		""},
	 { "delete_EuriborSwapIfrFix", _wrap_delete_EuriborSwapIfrFix, METH_O, "delete_EuriborSwapIfrFix(EuriborSwapIfrFix self)"},
	 { "EuriborSwapIfrFix_swigregister", EuriborSwapIfrFix_swigregister, METH_O, NULL},
	 { "EuriborSwapIfrFix_swiginit", EuriborSwapIfrFix_swiginit, METH_VARARGS, NULL},
	 { "new_EurLiborSwapIsdaFixA", _wrap_new_EurLiborSwapIsdaFixA, METH_VARARGS, "\n"
		"EurLiborSwapIsdaFixA(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_EurLiborSwapIsdaFixA(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EurLiborSwapIsdaFixA\n"
		""},
	 { "delete_EurLiborSwapIsdaFixA", _wrap_delete_EurLiborSwapIsdaFixA, METH_O, "delete_EurLiborSwapIsdaFixA(EurLiborSwapIsdaFixA self)"},
	 { "EurLiborSwapIsdaFixA_swigregister", EurLiborSwapIsdaFixA_swigregister, METH_O, NULL},
	 { "EurLiborSwapIsdaFixA_swiginit", EurLiborSwapIsdaFixA_swiginit, METH_VARARGS, NULL},
	 { "new_EurLiborSwapIsdaFixB", _wrap_new_EurLiborSwapIsdaFixB, METH_VARARGS, "\n"
		"EurLiborSwapIsdaFixB(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_EurLiborSwapIsdaFixB(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EurLiborSwapIsdaFixB\n"
		""},
	 { "delete_EurLiborSwapIsdaFixB", _wrap_delete_EurLiborSwapIsdaFixB, METH_O, "delete_EurLiborSwapIsdaFixB(EurLiborSwapIsdaFixB self)"},
	 { "EurLiborSwapIsdaFixB_swigregister", EurLiborSwapIsdaFixB_swigregister, METH_O, NULL},
	 { "EurLiborSwapIsdaFixB_swiginit", EurLiborSwapIsdaFixB_swiginit, METH_VARARGS, NULL},
	 { "new_EurLiborSwapIfrFix", _wrap_new_EurLiborSwapIfrFix, METH_VARARGS, "\n"
		"EurLiborSwapIfrFix(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_EurLiborSwapIfrFix(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> EurLiborSwapIfrFix\n"
		""},
	 { "delete_EurLiborSwapIfrFix", _wrap_delete_EurLiborSwapIfrFix, METH_O, "delete_EurLiborSwapIfrFix(EurLiborSwapIfrFix self)"},
	 { "EurLiborSwapIfrFix_swigregister", EurLiborSwapIfrFix_swigregister, METH_O, NULL},
	 { "EurLiborSwapIfrFix_swiginit", EurLiborSwapIfrFix_swiginit, METH_VARARGS, NULL},
	 { "new_ChfLiborSwapIsdaFix", _wrap_new_ChfLiborSwapIsdaFix, METH_VARARGS, "\n"
		"ChfLiborSwapIsdaFix(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_ChfLiborSwapIsdaFix(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> ChfLiborSwapIsdaFix\n"
		""},
	 { "delete_ChfLiborSwapIsdaFix", _wrap_delete_ChfLiborSwapIsdaFix, METH_O, "delete_ChfLiborSwapIsdaFix(ChfLiborSwapIsdaFix self)"},
	 { "ChfLiborSwapIsdaFix_swigregister", ChfLiborSwapIsdaFix_swigregister, METH_O, NULL},
	 { "ChfLiborSwapIsdaFix_swiginit", ChfLiborSwapIsdaFix_swiginit, METH_VARARGS, NULL},
	 { "new_GbpLiborSwapIsdaFix", _wrap_new_GbpLiborSwapIsdaFix, METH_VARARGS, "\n"
		"GbpLiborSwapIsdaFix(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_GbpLiborSwapIsdaFix(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> GbpLiborSwapIsdaFix\n"
		""},
	 { "delete_GbpLiborSwapIsdaFix", _wrap_delete_GbpLiborSwapIsdaFix, METH_O, "delete_GbpLiborSwapIsdaFix(GbpLiborSwapIsdaFix self)"},
	 { "GbpLiborSwapIsdaFix_swigregister", GbpLiborSwapIsdaFix_swigregister, METH_O, NULL},
	 { "GbpLiborSwapIsdaFix_swiginit", GbpLiborSwapIsdaFix_swiginit, METH_VARARGS, NULL},
	 { "new_JpyLiborSwapIsdaFixAm", _wrap_new_JpyLiborSwapIsdaFixAm, METH_VARARGS, "\n"
		"JpyLiborSwapIsdaFixAm(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_JpyLiborSwapIsdaFixAm(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> JpyLiborSwapIsdaFixAm\n"
		""},
	 { "delete_JpyLiborSwapIsdaFixAm", _wrap_delete_JpyLiborSwapIsdaFixAm, METH_O, "delete_JpyLiborSwapIsdaFixAm(JpyLiborSwapIsdaFixAm self)"},
	 { "JpyLiborSwapIsdaFixAm_swigregister", JpyLiborSwapIsdaFixAm_swigregister, METH_O, NULL},
	 { "JpyLiborSwapIsdaFixAm_swiginit", JpyLiborSwapIsdaFixAm_swiginit, METH_VARARGS, NULL},
	 { "new_JpyLiborSwapIsdaFixPm", _wrap_new_JpyLiborSwapIsdaFixPm, METH_VARARGS, "\n"
		"JpyLiborSwapIsdaFixPm(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_JpyLiborSwapIsdaFixPm(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> JpyLiborSwapIsdaFixPm\n"
		""},
	 { "delete_JpyLiborSwapIsdaFixPm", _wrap_delete_JpyLiborSwapIsdaFixPm, METH_O, "delete_JpyLiborSwapIsdaFixPm(JpyLiborSwapIsdaFixPm self)"},
	 { "JpyLiborSwapIsdaFixPm_swigregister", JpyLiborSwapIsdaFixPm_swigregister, METH_O, NULL},
	 { "JpyLiborSwapIsdaFixPm_swiginit", JpyLiborSwapIsdaFixPm_swiginit, METH_VARARGS, NULL},
	 { "new_UsdLiborSwapIsdaFixAm", _wrap_new_UsdLiborSwapIsdaFixAm, METH_VARARGS, "\n"
		"UsdLiborSwapIsdaFixAm(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_UsdLiborSwapIsdaFixAm(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> UsdLiborSwapIsdaFixAm\n"
		""},
	 { "delete_UsdLiborSwapIsdaFixAm", _wrap_delete_UsdLiborSwapIsdaFixAm, METH_O, "delete_UsdLiborSwapIsdaFixAm(UsdLiborSwapIsdaFixAm self)"},
	 { "UsdLiborSwapIsdaFixAm_swigregister", UsdLiborSwapIsdaFixAm_swigregister, METH_O, NULL},
	 { "UsdLiborSwapIsdaFixAm_swiginit", UsdLiborSwapIsdaFixAm_swiginit, METH_VARARGS, NULL},
	 { "new_UsdLiborSwapIsdaFixPm", _wrap_new_UsdLiborSwapIsdaFixPm, METH_VARARGS, "\n"
		"UsdLiborSwapIsdaFixPm(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())\n"
		"new_UsdLiborSwapIsdaFixPm(Period tenor, YieldTermStructureHandle h1, YieldTermStructureHandle h2) -> UsdLiborSwapIsdaFixPm\n"
		""},
	 { "delete_UsdLiborSwapIsdaFixPm", _wrap_delete_UsdLiborSwapIsdaFixPm, METH_O, "delete_UsdLiborSwapIsdaFixPm(UsdLiborSwapIsdaFixPm self)"},
	 { "UsdLiborSwapIsdaFixPm_swigregister", UsdLiborSwapIsdaFixPm_swigregister, METH_O, NULL},
	 { "UsdLiborSwapIsdaFixPm_swiginit", UsdLiborSwapIsdaFixPm_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor", _wrap_new_Bibor, METH_VARARGS, "Bibor(Period tenor, YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor", _wrap_delete_Bibor, METH_O, "delete_Bibor(Bibor self)"},
	 { "Bibor_swigregister", Bibor_swigregister, METH_O, NULL},
	 { "Bibor_swiginit", Bibor_swiginit, METH_VARARGS, NULL},
	 { "new_BiborSW", _wrap_new_BiborSW, METH_VARARGS, "BiborSW(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_BiborSW", _wrap_delete_BiborSW, METH_O, "delete_BiborSW(BiborSW self)"},
	 { "BiborSW_swigregister", BiborSW_swigregister, METH_O, NULL},
	 { "BiborSW_swiginit", BiborSW_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor1M", _wrap_new_Bibor1M, METH_VARARGS, "Bibor1M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor1M", _wrap_delete_Bibor1M, METH_O, "delete_Bibor1M(Bibor1M self)"},
	 { "Bibor1M_swigregister", Bibor1M_swigregister, METH_O, NULL},
	 { "Bibor1M_swiginit", Bibor1M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor2M", _wrap_new_Bibor2M, METH_VARARGS, "Bibor2M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor2M", _wrap_delete_Bibor2M, METH_O, "delete_Bibor2M(Bibor2M self)"},
	 { "Bibor2M_swigregister", Bibor2M_swigregister, METH_O, NULL},
	 { "Bibor2M_swiginit", Bibor2M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor3M", _wrap_new_Bibor3M, METH_VARARGS, "Bibor3M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor3M", _wrap_delete_Bibor3M, METH_O, "delete_Bibor3M(Bibor3M self)"},
	 { "Bibor3M_swigregister", Bibor3M_swigregister, METH_O, NULL},
	 { "Bibor3M_swiginit", Bibor3M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor6M", _wrap_new_Bibor6M, METH_VARARGS, "Bibor6M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor6M", _wrap_delete_Bibor6M, METH_O, "delete_Bibor6M(Bibor6M self)"},
	 { "Bibor6M_swigregister", Bibor6M_swigregister, METH_O, NULL},
	 { "Bibor6M_swiginit", Bibor6M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor9M", _wrap_new_Bibor9M, METH_VARARGS, "Bibor9M(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor9M", _wrap_delete_Bibor9M, METH_O, "delete_Bibor9M(Bibor9M self)"},
	 { "Bibor9M_swigregister", Bibor9M_swigregister, METH_O, NULL},
	 { "Bibor9M_swiginit", Bibor9M_swiginit, METH_VARARGS, NULL},
	 { "new_Bibor1Y", _wrap_new_Bibor1Y, METH_VARARGS, "Bibor1Y(YieldTermStructureHandle h=Handle< YieldTermStructure >())"},
	 { "delete_Bibor1Y", _wrap_delete_Bibor1Y, METH_O, "delete_Bibor1Y(Bibor1Y self)"},
	 { "Bibor1Y_swigregister", Bibor1Y_swigregister, METH_O, NULL},
	 { "Bibor1Y_swiginit", Bibor1Y_swiginit, METH_VARARGS, NULL},
	 { "new_DateGeneration", _wrap_new_DateGeneration, METH_NOARGS, "new_DateGeneration() -> DateGeneration"},
	 { "delete_DateGeneration", _wrap_delete_DateGeneration, METH_O, "delete_DateGeneration(DateGeneration self)"},
	 { "DateGeneration_swigregister", DateGeneration_swigregister, METH_O, NULL},
	 { "DateGeneration_swiginit", DateGeneration_swiginit, METH_VARARGS, NULL},
	 { "new_Schedule", _wrap_new_Schedule, METH_VARARGS, "\n"
		"Schedule(DateVector arg1, Calendar calendar=NullCalendar(), BusinessDayConvention const convention=Unadjusted, ext::optional< BusinessDayConvention > terminationDateConvention=ext::nullopt, ext::optional< Period > tenor=ext::nullopt, ext::optional< DateGeneration::Rule > rule=ext::nullopt, ext::optional< bool > endOfMonth=ext::nullopt, BoolVector isRegular=std::vector< bool >(0))\n"
		"Schedule(Date effectiveDate, Date terminationDate, Period tenor, Calendar calendar, BusinessDayConvention convention, BusinessDayConvention terminationDateConvention, DateGeneration::Rule rule, bool endOfMonth, Date firstDate=Date(), Date nextToLastDate=Date())\n"
		"new_Schedule() -> Schedule\n"
		""},
	 { "Schedule___len__", _wrap_Schedule___len__, METH_O, "Schedule___len__(Schedule self) -> Size"},
	 { "Schedule_previousDate", _wrap_Schedule_previousDate, METH_VARARGS, "Schedule_previousDate(Schedule self, Date refDate) -> Date"},
	 { "Schedule_nextDate", _wrap_Schedule_nextDate, METH_VARARGS, "Schedule_nextDate(Schedule self, Date refDate) -> Date"},
	 { "Schedule_dates", _wrap_Schedule_dates, METH_O, "Schedule_dates(Schedule self) -> DateVector"},
	 { "Schedule_hasIsRegular", _wrap_Schedule_hasIsRegular, METH_O, "Schedule_hasIsRegular(Schedule self) -> bool"},
	 { "Schedule_isRegular", _wrap_Schedule_isRegular, METH_VARARGS, "\n"
		"Schedule_isRegular(Schedule self, Size i) -> bool\n"
		"Schedule_isRegular(Schedule self) -> BoolVector\n"
		""},
	 { "Schedule_calendar", _wrap_Schedule_calendar, METH_O, "Schedule_calendar(Schedule self) -> Calendar"},
	 { "Schedule_startDate", _wrap_Schedule_startDate, METH_O, "Schedule_startDate(Schedule self) -> Date"},
	 { "Schedule_endDate", _wrap_Schedule_endDate, METH_O, "Schedule_endDate(Schedule self) -> Date"},
	 { "Schedule_hasTenor", _wrap_Schedule_hasTenor, METH_O, "Schedule_hasTenor(Schedule self) -> bool"},
	 { "Schedule_tenor", _wrap_Schedule_tenor, METH_O, "Schedule_tenor(Schedule self) -> Period"},
	 { "Schedule_businessDayConvention", _wrap_Schedule_businessDayConvention, METH_O, "Schedule_businessDayConvention(Schedule self) -> BusinessDayConvention"},
	 { "Schedule_hasTerminationDateBusinessDayConvention", _wrap_Schedule_hasTerminationDateBusinessDayConvention, METH_O, "Schedule_hasTerminationDateBusinessDayConvention(Schedule self) -> bool"},
	 { "Schedule_terminationDateBusinessDayConvention", _wrap_Schedule_terminationDateBusinessDayConvention, METH_O, "Schedule_terminationDateBusinessDayConvention(Schedule self) -> BusinessDayConvention"},
	 { "Schedule_hasRule", _wrap_Schedule_hasRule, METH_O, "Schedule_hasRule(Schedule self) -> bool"},
	 { "Schedule_rule", _wrap_Schedule_rule, METH_O, "Schedule_rule(Schedule self) -> DateGeneration::Rule"},
	 { "Schedule_hasEndOfMonth", _wrap_Schedule_hasEndOfMonth, METH_O, "Schedule_hasEndOfMonth(Schedule self) -> bool"},
	 { "Schedule_endOfMonth", _wrap_Schedule_endOfMonth, METH_O, "Schedule_endOfMonth(Schedule self) -> bool"},
	 { "Schedule_after", _wrap_Schedule_after, METH_VARARGS, "Schedule_after(Schedule self, Date truncationDate) -> Schedule"},
	 { "Schedule_until", _wrap_Schedule_until, METH_VARARGS, "Schedule_until(Schedule self, Date truncationDate) -> Schedule"},
	 { "Schedule___getitem__", _wrap_Schedule___getitem__, METH_VARARGS, "Schedule___getitem__(Schedule self, Integer i) -> Date"},
	 { "delete_Schedule", _wrap_delete_Schedule, METH_O, "delete_Schedule(Schedule self)"},
	 { "Schedule_swigregister", Schedule_swigregister, METH_O, NULL},
	 { "Schedule_swiginit", Schedule_swiginit, METH_VARARGS, NULL},
	 { "new__MakeSchedule", _wrap_new__MakeSchedule, METH_NOARGS, "new__MakeSchedule() -> _MakeSchedule"},
	 { "_MakeSchedule_fromDate", _wrap__MakeSchedule_fromDate, METH_VARARGS, "_MakeSchedule_fromDate(_MakeSchedule self, Date effectiveDate) -> _MakeSchedule"},
	 { "_MakeSchedule_to", _wrap__MakeSchedule_to, METH_VARARGS, "_MakeSchedule_to(_MakeSchedule self, Date terminationDate) -> _MakeSchedule"},
	 { "_MakeSchedule_withTenor", _wrap__MakeSchedule_withTenor, METH_VARARGS, "_MakeSchedule_withTenor(_MakeSchedule self, Period arg2) -> _MakeSchedule"},
	 { "_MakeSchedule_withFrequency", _wrap__MakeSchedule_withFrequency, METH_VARARGS, "_MakeSchedule_withFrequency(_MakeSchedule self, Frequency arg2) -> _MakeSchedule"},
	 { "_MakeSchedule_withCalendar", _wrap__MakeSchedule_withCalendar, METH_VARARGS, "_MakeSchedule_withCalendar(_MakeSchedule self, Calendar arg2) -> _MakeSchedule"},
	 { "_MakeSchedule_withConvention", _wrap__MakeSchedule_withConvention, METH_VARARGS, "_MakeSchedule_withConvention(_MakeSchedule self, BusinessDayConvention arg2) -> _MakeSchedule"},
	 { "_MakeSchedule_withTerminationDateConvention", _wrap__MakeSchedule_withTerminationDateConvention, METH_VARARGS, "_MakeSchedule_withTerminationDateConvention(_MakeSchedule self, BusinessDayConvention arg2) -> _MakeSchedule"},
	 { "_MakeSchedule_withRule", _wrap__MakeSchedule_withRule, METH_VARARGS, "_MakeSchedule_withRule(_MakeSchedule self, DateGeneration::Rule arg2) -> _MakeSchedule"},
	 { "_MakeSchedule_forwards", _wrap__MakeSchedule_forwards, METH_O, "_MakeSchedule_forwards(_MakeSchedule self) -> _MakeSchedule"},
	 { "_MakeSchedule_backwards", _wrap__MakeSchedule_backwards, METH_O, "_MakeSchedule_backwards(_MakeSchedule self) -> _MakeSchedule"},
	 { "_MakeSchedule_endOfMonth", _wrap__MakeSchedule_endOfMonth, METH_VARARGS, "_MakeSchedule_endOfMonth(_MakeSchedule self, bool flag=True) -> _MakeSchedule"},
	 { "_MakeSchedule_withFirstDate", _wrap__MakeSchedule_withFirstDate, METH_VARARGS, "_MakeSchedule_withFirstDate(_MakeSchedule self, Date d) -> _MakeSchedule"},
	 { "_MakeSchedule_withNextToLastDate", _wrap__MakeSchedule_withNextToLastDate, METH_VARARGS, "_MakeSchedule_withNextToLastDate(_MakeSchedule self, Date d) -> _MakeSchedule"},
	 { "_MakeSchedule_schedule", _wrap__MakeSchedule_schedule, METH_O, "_MakeSchedule_schedule(_MakeSchedule self) -> Schedule"},
	 { "delete__MakeSchedule", _wrap_delete__MakeSchedule, METH_O, "delete__MakeSchedule(_MakeSchedule self)"},
	 { "_MakeSchedule_swigregister", _MakeSchedule_swigregister, METH_O, NULL},
	 { "_MakeSchedule_swiginit", _MakeSchedule_swiginit, METH_VARARGS, NULL},
	 { "VolatilityTermStructure_minStrike", _wrap_VolatilityTermStructure_minStrike, METH_O, "VolatilityTermStructure_minStrike(VolatilityTermStructure self) -> Real"},
	 { "VolatilityTermStructure_maxStrike", _wrap_VolatilityTermStructure_maxStrike, METH_O, "VolatilityTermStructure_maxStrike(VolatilityTermStructure self) -> Real"},
	 { "delete_VolatilityTermStructure", _wrap_delete_VolatilityTermStructure, METH_O, "delete_VolatilityTermStructure(VolatilityTermStructure self)"},
	 { "VolatilityTermStructure_swigregister", VolatilityTermStructure_swigregister, METH_O, NULL},
	 { "BlackVolTermStructure_blackVol", _wrap_BlackVolTermStructure_blackVol, METH_VARARGS, "\n"
		"BlackVolTermStructure_blackVol(BlackVolTermStructure self, Date arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		"BlackVolTermStructure_blackVol(BlackVolTermStructure self, Time arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "BlackVolTermStructure_blackVariance", _wrap_BlackVolTermStructure_blackVariance, METH_VARARGS, "\n"
		"BlackVolTermStructure_blackVariance(BlackVolTermStructure self, Date arg2, Real strike, bool extrapolate=False) -> Real\n"
		"BlackVolTermStructure_blackVariance(BlackVolTermStructure self, Time arg2, Real strike, bool extrapolate=False) -> Real\n"
		""},
	 { "BlackVolTermStructure_blackForwardVol", _wrap_BlackVolTermStructure_blackForwardVol, METH_VARARGS, "\n"
		"BlackVolTermStructure_blackForwardVol(BlackVolTermStructure self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Volatility\n"
		"BlackVolTermStructure_blackForwardVol(BlackVolTermStructure self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "BlackVolTermStructure_blackForwardVariance", _wrap_BlackVolTermStructure_blackForwardVariance, METH_VARARGS, "\n"
		"BlackVolTermStructure_blackForwardVariance(BlackVolTermStructure self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Real\n"
		"BlackVolTermStructure_blackForwardVariance(BlackVolTermStructure self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Real\n"
		""},
	 { "delete_BlackVolTermStructure", _wrap_delete_BlackVolTermStructure, METH_O, "delete_BlackVolTermStructure(BlackVolTermStructure self)"},
	 { "BlackVolTermStructure_swigregister", BlackVolTermStructure_swigregister, METH_O, NULL},
	 { "new_BlackVolTermStructureHandle", _wrap_new_BlackVolTermStructureHandle, METH_VARARGS, "BlackVolTermStructureHandle(ext::shared_ptr< BlackVolTermStructure > const & arg1=ext::shared_ptr())"},
	 { "BlackVolTermStructureHandle___deref__", _wrap_BlackVolTermStructureHandle___deref__, METH_O, "BlackVolTermStructureHandle___deref__(BlackVolTermStructureHandle self) -> ext::shared_ptr< BlackVolTermStructure >"},
	 { "BlackVolTermStructureHandle_currentLink", _wrap_BlackVolTermStructureHandle_currentLink, METH_O, "BlackVolTermStructureHandle_currentLink(BlackVolTermStructureHandle self) -> ext::shared_ptr< BlackVolTermStructure >"},
	 { "BlackVolTermStructureHandle___nonzero__", _wrap_BlackVolTermStructureHandle___nonzero__, METH_O, "BlackVolTermStructureHandle___nonzero__(BlackVolTermStructureHandle self) -> bool"},
	 { "BlackVolTermStructureHandle___bool__", _wrap_BlackVolTermStructureHandle___bool__, METH_O, "BlackVolTermStructureHandle___bool__(BlackVolTermStructureHandle self) -> bool"},
	 { "BlackVolTermStructureHandle_asObservable", _wrap_BlackVolTermStructureHandle_asObservable, METH_O, "BlackVolTermStructureHandle_asObservable(BlackVolTermStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_BlackVolTermStructureHandle", _wrap_delete_BlackVolTermStructureHandle, METH_O, "delete_BlackVolTermStructureHandle(BlackVolTermStructureHandle self)"},
	 { "BlackVolTermStructureHandle_blackVol", _wrap_BlackVolTermStructureHandle_blackVol, METH_VARARGS, "\n"
		"BlackVolTermStructureHandle_blackVol(BlackVolTermStructureHandle self, Date arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		"BlackVolTermStructureHandle_blackVol(BlackVolTermStructureHandle self, Time arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "BlackVolTermStructureHandle_blackVariance", _wrap_BlackVolTermStructureHandle_blackVariance, METH_VARARGS, "\n"
		"BlackVolTermStructureHandle_blackVariance(BlackVolTermStructureHandle self, Date arg2, Real strike, bool extrapolate=False) -> Real\n"
		"BlackVolTermStructureHandle_blackVariance(BlackVolTermStructureHandle self, Time arg2, Real strike, bool extrapolate=False) -> Real\n"
		""},
	 { "BlackVolTermStructureHandle_blackForwardVol", _wrap_BlackVolTermStructureHandle_blackForwardVol, METH_VARARGS, "\n"
		"BlackVolTermStructureHandle_blackForwardVol(BlackVolTermStructureHandle self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Volatility\n"
		"BlackVolTermStructureHandle_blackForwardVol(BlackVolTermStructureHandle self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "BlackVolTermStructureHandle_blackForwardVariance", _wrap_BlackVolTermStructureHandle_blackForwardVariance, METH_VARARGS, "\n"
		"BlackVolTermStructureHandle_blackForwardVariance(BlackVolTermStructureHandle self, Date arg2, Date arg3, Real strike, bool extrapolate=False) -> Real\n"
		"BlackVolTermStructureHandle_blackForwardVariance(BlackVolTermStructureHandle self, Time arg2, Time arg3, Real strike, bool extrapolate=False) -> Real\n"
		""},
	 { "BlackVolTermStructureHandle_minStrike", _wrap_BlackVolTermStructureHandle_minStrike, METH_O, "BlackVolTermStructureHandle_minStrike(BlackVolTermStructureHandle self) -> Real"},
	 { "BlackVolTermStructureHandle_maxStrike", _wrap_BlackVolTermStructureHandle_maxStrike, METH_O, "BlackVolTermStructureHandle_maxStrike(BlackVolTermStructureHandle self) -> Real"},
	 { "BlackVolTermStructureHandle_dayCounter", _wrap_BlackVolTermStructureHandle_dayCounter, METH_O, "BlackVolTermStructureHandle_dayCounter(BlackVolTermStructureHandle self) -> DayCounter"},
	 { "BlackVolTermStructureHandle_timeFromReference", _wrap_BlackVolTermStructureHandle_timeFromReference, METH_VARARGS, "BlackVolTermStructureHandle_timeFromReference(BlackVolTermStructureHandle self, Date date) -> Time"},
	 { "BlackVolTermStructureHandle_calendar", _wrap_BlackVolTermStructureHandle_calendar, METH_O, "BlackVolTermStructureHandle_calendar(BlackVolTermStructureHandle self) -> Calendar"},
	 { "BlackVolTermStructureHandle_referenceDate", _wrap_BlackVolTermStructureHandle_referenceDate, METH_O, "BlackVolTermStructureHandle_referenceDate(BlackVolTermStructureHandle self) -> Date"},
	 { "BlackVolTermStructureHandle_maxDate", _wrap_BlackVolTermStructureHandle_maxDate, METH_O, "BlackVolTermStructureHandle_maxDate(BlackVolTermStructureHandle self) -> Date"},
	 { "BlackVolTermStructureHandle_maxTime", _wrap_BlackVolTermStructureHandle_maxTime, METH_O, "BlackVolTermStructureHandle_maxTime(BlackVolTermStructureHandle self) -> Time"},
	 { "BlackVolTermStructureHandle_enableExtrapolation", _wrap_BlackVolTermStructureHandle_enableExtrapolation, METH_O, "BlackVolTermStructureHandle_enableExtrapolation(BlackVolTermStructureHandle self)"},
	 { "BlackVolTermStructureHandle_disableExtrapolation", _wrap_BlackVolTermStructureHandle_disableExtrapolation, METH_O, "BlackVolTermStructureHandle_disableExtrapolation(BlackVolTermStructureHandle self)"},
	 { "BlackVolTermStructureHandle_allowsExtrapolation", _wrap_BlackVolTermStructureHandle_allowsExtrapolation, METH_O, "BlackVolTermStructureHandle_allowsExtrapolation(BlackVolTermStructureHandle self) -> bool"},
	 { "BlackVolTermStructureHandle_swigregister", BlackVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "BlackVolTermStructureHandle_swiginit", BlackVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableBlackVolTermStructureHandle", _wrap_new_RelinkableBlackVolTermStructureHandle, METH_VARARGS, "RelinkableBlackVolTermStructureHandle(ext::shared_ptr< BlackVolTermStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableBlackVolTermStructureHandle_linkTo", _wrap_RelinkableBlackVolTermStructureHandle_linkTo, METH_VARARGS, "RelinkableBlackVolTermStructureHandle_linkTo(RelinkableBlackVolTermStructureHandle self, ext::shared_ptr< BlackVolTermStructure > const & arg2)"},
	 { "RelinkableBlackVolTermStructureHandle_reset", _wrap_RelinkableBlackVolTermStructureHandle_reset, METH_O, "RelinkableBlackVolTermStructureHandle_reset(RelinkableBlackVolTermStructureHandle self)"},
	 { "delete_RelinkableBlackVolTermStructureHandle", _wrap_delete_RelinkableBlackVolTermStructureHandle, METH_O, "delete_RelinkableBlackVolTermStructureHandle(RelinkableBlackVolTermStructureHandle self)"},
	 { "RelinkableBlackVolTermStructureHandle_swigregister", RelinkableBlackVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableBlackVolTermStructureHandle_swiginit", RelinkableBlackVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "LocalVolTermStructure_localVol", _wrap_LocalVolTermStructure_localVol, METH_VARARGS, "\n"
		"LocalVolTermStructure_localVol(LocalVolTermStructure self, Date arg2, Real u, bool extrapolate=False) -> Volatility\n"
		"LocalVolTermStructure_localVol(LocalVolTermStructure self, Time arg2, Real u, bool extrapolate=False) -> Volatility\n"
		""},
	 { "delete_LocalVolTermStructure", _wrap_delete_LocalVolTermStructure, METH_O, "delete_LocalVolTermStructure(LocalVolTermStructure self)"},
	 { "LocalVolTermStructure_swigregister", LocalVolTermStructure_swigregister, METH_O, NULL},
	 { "new_LocalVolTermStructureHandle", _wrap_new_LocalVolTermStructureHandle, METH_VARARGS, "LocalVolTermStructureHandle(ext::shared_ptr< LocalVolTermStructure > const & arg1=ext::shared_ptr())"},
	 { "LocalVolTermStructureHandle___deref__", _wrap_LocalVolTermStructureHandle___deref__, METH_O, "LocalVolTermStructureHandle___deref__(LocalVolTermStructureHandle self) -> ext::shared_ptr< LocalVolTermStructure >"},
	 { "LocalVolTermStructureHandle_currentLink", _wrap_LocalVolTermStructureHandle_currentLink, METH_O, "LocalVolTermStructureHandle_currentLink(LocalVolTermStructureHandle self) -> ext::shared_ptr< LocalVolTermStructure >"},
	 { "LocalVolTermStructureHandle___nonzero__", _wrap_LocalVolTermStructureHandle___nonzero__, METH_O, "LocalVolTermStructureHandle___nonzero__(LocalVolTermStructureHandle self) -> bool"},
	 { "LocalVolTermStructureHandle___bool__", _wrap_LocalVolTermStructureHandle___bool__, METH_O, "LocalVolTermStructureHandle___bool__(LocalVolTermStructureHandle self) -> bool"},
	 { "LocalVolTermStructureHandle_asObservable", _wrap_LocalVolTermStructureHandle_asObservable, METH_O, "LocalVolTermStructureHandle_asObservable(LocalVolTermStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_LocalVolTermStructureHandle", _wrap_delete_LocalVolTermStructureHandle, METH_O, "delete_LocalVolTermStructureHandle(LocalVolTermStructureHandle self)"},
	 { "LocalVolTermStructureHandle_localVol", _wrap_LocalVolTermStructureHandle_localVol, METH_VARARGS, "\n"
		"LocalVolTermStructureHandle_localVol(LocalVolTermStructureHandle self, Date arg2, Real u, bool extrapolate=False) -> Volatility\n"
		"LocalVolTermStructureHandle_localVol(LocalVolTermStructureHandle self, Time arg2, Real u, bool extrapolate=False) -> Volatility\n"
		""},
	 { "LocalVolTermStructureHandle_minStrike", _wrap_LocalVolTermStructureHandle_minStrike, METH_O, "LocalVolTermStructureHandle_minStrike(LocalVolTermStructureHandle self) -> Real"},
	 { "LocalVolTermStructureHandle_maxStrike", _wrap_LocalVolTermStructureHandle_maxStrike, METH_O, "LocalVolTermStructureHandle_maxStrike(LocalVolTermStructureHandle self) -> Real"},
	 { "LocalVolTermStructureHandle_dayCounter", _wrap_LocalVolTermStructureHandle_dayCounter, METH_O, "LocalVolTermStructureHandle_dayCounter(LocalVolTermStructureHandle self) -> DayCounter"},
	 { "LocalVolTermStructureHandle_timeFromReference", _wrap_LocalVolTermStructureHandle_timeFromReference, METH_VARARGS, "LocalVolTermStructureHandle_timeFromReference(LocalVolTermStructureHandle self, Date date) -> Time"},
	 { "LocalVolTermStructureHandle_calendar", _wrap_LocalVolTermStructureHandle_calendar, METH_O, "LocalVolTermStructureHandle_calendar(LocalVolTermStructureHandle self) -> Calendar"},
	 { "LocalVolTermStructureHandle_referenceDate", _wrap_LocalVolTermStructureHandle_referenceDate, METH_O, "LocalVolTermStructureHandle_referenceDate(LocalVolTermStructureHandle self) -> Date"},
	 { "LocalVolTermStructureHandle_maxDate", _wrap_LocalVolTermStructureHandle_maxDate, METH_O, "LocalVolTermStructureHandle_maxDate(LocalVolTermStructureHandle self) -> Date"},
	 { "LocalVolTermStructureHandle_maxTime", _wrap_LocalVolTermStructureHandle_maxTime, METH_O, "LocalVolTermStructureHandle_maxTime(LocalVolTermStructureHandle self) -> Time"},
	 { "LocalVolTermStructureHandle_enableExtrapolation", _wrap_LocalVolTermStructureHandle_enableExtrapolation, METH_O, "LocalVolTermStructureHandle_enableExtrapolation(LocalVolTermStructureHandle self)"},
	 { "LocalVolTermStructureHandle_disableExtrapolation", _wrap_LocalVolTermStructureHandle_disableExtrapolation, METH_O, "LocalVolTermStructureHandle_disableExtrapolation(LocalVolTermStructureHandle self)"},
	 { "LocalVolTermStructureHandle_allowsExtrapolation", _wrap_LocalVolTermStructureHandle_allowsExtrapolation, METH_O, "LocalVolTermStructureHandle_allowsExtrapolation(LocalVolTermStructureHandle self) -> bool"},
	 { "LocalVolTermStructureHandle_swigregister", LocalVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "LocalVolTermStructureHandle_swiginit", LocalVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableLocalVolTermStructureHandle", _wrap_new_RelinkableLocalVolTermStructureHandle, METH_VARARGS, "RelinkableLocalVolTermStructureHandle(ext::shared_ptr< LocalVolTermStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableLocalVolTermStructureHandle_linkTo", _wrap_RelinkableLocalVolTermStructureHandle_linkTo, METH_VARARGS, "RelinkableLocalVolTermStructureHandle_linkTo(RelinkableLocalVolTermStructureHandle self, ext::shared_ptr< LocalVolTermStructure > const & arg2)"},
	 { "RelinkableLocalVolTermStructureHandle_reset", _wrap_RelinkableLocalVolTermStructureHandle_reset, METH_O, "RelinkableLocalVolTermStructureHandle_reset(RelinkableLocalVolTermStructureHandle self)"},
	 { "delete_RelinkableLocalVolTermStructureHandle", _wrap_delete_RelinkableLocalVolTermStructureHandle, METH_O, "delete_RelinkableLocalVolTermStructureHandle(RelinkableLocalVolTermStructureHandle self)"},
	 { "RelinkableLocalVolTermStructureHandle_swigregister", RelinkableLocalVolTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableLocalVolTermStructureHandle_swiginit", RelinkableLocalVolTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "OptionletVolatilityStructure_volatility", _wrap_OptionletVolatilityStructure_volatility, METH_VARARGS, "\n"
		"OptionletVolatilityStructure_volatility(OptionletVolatilityStructure self, Date arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		"OptionletVolatilityStructure_volatility(OptionletVolatilityStructure self, Time arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "OptionletVolatilityStructure_blackVariance", _wrap_OptionletVolatilityStructure_blackVariance, METH_VARARGS, "\n"
		"OptionletVolatilityStructure_blackVariance(OptionletVolatilityStructure self, Date arg2, Rate strike, bool extrapolate=False) -> Real\n"
		"OptionletVolatilityStructure_blackVariance(OptionletVolatilityStructure self, Time arg2, Rate strike, bool extrapolate=False) -> Real\n"
		""},
	 { "delete_OptionletVolatilityStructure", _wrap_delete_OptionletVolatilityStructure, METH_O, "delete_OptionletVolatilityStructure(OptionletVolatilityStructure self)"},
	 { "OptionletVolatilityStructure_swigregister", OptionletVolatilityStructure_swigregister, METH_O, NULL},
	 { "new_OptionletVolatilityStructureHandle", _wrap_new_OptionletVolatilityStructureHandle, METH_VARARGS, "OptionletVolatilityStructureHandle(ext::shared_ptr< OptionletVolatilityStructure > const & arg1=ext::shared_ptr())"},
	 { "OptionletVolatilityStructureHandle___deref__", _wrap_OptionletVolatilityStructureHandle___deref__, METH_O, "OptionletVolatilityStructureHandle___deref__(OptionletVolatilityStructureHandle self) -> ext::shared_ptr< OptionletVolatilityStructure >"},
	 { "OptionletVolatilityStructureHandle_currentLink", _wrap_OptionletVolatilityStructureHandle_currentLink, METH_O, "OptionletVolatilityStructureHandle_currentLink(OptionletVolatilityStructureHandle self) -> ext::shared_ptr< OptionletVolatilityStructure >"},
	 { "OptionletVolatilityStructureHandle___nonzero__", _wrap_OptionletVolatilityStructureHandle___nonzero__, METH_O, "OptionletVolatilityStructureHandle___nonzero__(OptionletVolatilityStructureHandle self) -> bool"},
	 { "OptionletVolatilityStructureHandle___bool__", _wrap_OptionletVolatilityStructureHandle___bool__, METH_O, "OptionletVolatilityStructureHandle___bool__(OptionletVolatilityStructureHandle self) -> bool"},
	 { "OptionletVolatilityStructureHandle_asObservable", _wrap_OptionletVolatilityStructureHandle_asObservable, METH_O, "OptionletVolatilityStructureHandle_asObservable(OptionletVolatilityStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_OptionletVolatilityStructureHandle", _wrap_delete_OptionletVolatilityStructureHandle, METH_O, "delete_OptionletVolatilityStructureHandle(OptionletVolatilityStructureHandle self)"},
	 { "OptionletVolatilityStructureHandle_volatility", _wrap_OptionletVolatilityStructureHandle_volatility, METH_VARARGS, "\n"
		"OptionletVolatilityStructureHandle_volatility(OptionletVolatilityStructureHandle self, Date arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		"OptionletVolatilityStructureHandle_volatility(OptionletVolatilityStructureHandle self, Time arg2, Real strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "OptionletVolatilityStructureHandle_blackVariance", _wrap_OptionletVolatilityStructureHandle_blackVariance, METH_VARARGS, "\n"
		"OptionletVolatilityStructureHandle_blackVariance(OptionletVolatilityStructureHandle self, Date arg2, Rate strike, bool extrapolate=False) -> Real\n"
		"OptionletVolatilityStructureHandle_blackVariance(OptionletVolatilityStructureHandle self, Time arg2, Rate strike, bool extrapolate=False) -> Real\n"
		""},
	 { "OptionletVolatilityStructureHandle_minStrike", _wrap_OptionletVolatilityStructureHandle_minStrike, METH_O, "OptionletVolatilityStructureHandle_minStrike(OptionletVolatilityStructureHandle self) -> Real"},
	 { "OptionletVolatilityStructureHandle_maxStrike", _wrap_OptionletVolatilityStructureHandle_maxStrike, METH_O, "OptionletVolatilityStructureHandle_maxStrike(OptionletVolatilityStructureHandle self) -> Real"},
	 { "OptionletVolatilityStructureHandle_dayCounter", _wrap_OptionletVolatilityStructureHandle_dayCounter, METH_O, "OptionletVolatilityStructureHandle_dayCounter(OptionletVolatilityStructureHandle self) -> DayCounter"},
	 { "OptionletVolatilityStructureHandle_timeFromReference", _wrap_OptionletVolatilityStructureHandle_timeFromReference, METH_VARARGS, "OptionletVolatilityStructureHandle_timeFromReference(OptionletVolatilityStructureHandle self, Date date) -> Time"},
	 { "OptionletVolatilityStructureHandle_calendar", _wrap_OptionletVolatilityStructureHandle_calendar, METH_O, "OptionletVolatilityStructureHandle_calendar(OptionletVolatilityStructureHandle self) -> Calendar"},
	 { "OptionletVolatilityStructureHandle_referenceDate", _wrap_OptionletVolatilityStructureHandle_referenceDate, METH_O, "OptionletVolatilityStructureHandle_referenceDate(OptionletVolatilityStructureHandle self) -> Date"},
	 { "OptionletVolatilityStructureHandle_maxDate", _wrap_OptionletVolatilityStructureHandle_maxDate, METH_O, "OptionletVolatilityStructureHandle_maxDate(OptionletVolatilityStructureHandle self) -> Date"},
	 { "OptionletVolatilityStructureHandle_maxTime", _wrap_OptionletVolatilityStructureHandle_maxTime, METH_O, "OptionletVolatilityStructureHandle_maxTime(OptionletVolatilityStructureHandle self) -> Time"},
	 { "OptionletVolatilityStructureHandle_enableExtrapolation", _wrap_OptionletVolatilityStructureHandle_enableExtrapolation, METH_O, "OptionletVolatilityStructureHandle_enableExtrapolation(OptionletVolatilityStructureHandle self)"},
	 { "OptionletVolatilityStructureHandle_disableExtrapolation", _wrap_OptionletVolatilityStructureHandle_disableExtrapolation, METH_O, "OptionletVolatilityStructureHandle_disableExtrapolation(OptionletVolatilityStructureHandle self)"},
	 { "OptionletVolatilityStructureHandle_allowsExtrapolation", _wrap_OptionletVolatilityStructureHandle_allowsExtrapolation, METH_O, "OptionletVolatilityStructureHandle_allowsExtrapolation(OptionletVolatilityStructureHandle self) -> bool"},
	 { "OptionletVolatilityStructureHandle_swigregister", OptionletVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "OptionletVolatilityStructureHandle_swiginit", OptionletVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableOptionletVolatilityStructureHandle", _wrap_new_RelinkableOptionletVolatilityStructureHandle, METH_VARARGS, "RelinkableOptionletVolatilityStructureHandle(ext::shared_ptr< OptionletVolatilityStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableOptionletVolatilityStructureHandle_linkTo", _wrap_RelinkableOptionletVolatilityStructureHandle_linkTo, METH_VARARGS, "RelinkableOptionletVolatilityStructureHandle_linkTo(RelinkableOptionletVolatilityStructureHandle self, ext::shared_ptr< OptionletVolatilityStructure > const & arg2)"},
	 { "RelinkableOptionletVolatilityStructureHandle_reset", _wrap_RelinkableOptionletVolatilityStructureHandle_reset, METH_O, "RelinkableOptionletVolatilityStructureHandle_reset(RelinkableOptionletVolatilityStructureHandle self)"},
	 { "delete_RelinkableOptionletVolatilityStructureHandle", _wrap_delete_RelinkableOptionletVolatilityStructureHandle, METH_O, "delete_RelinkableOptionletVolatilityStructureHandle(RelinkableOptionletVolatilityStructureHandle self)"},
	 { "RelinkableOptionletVolatilityStructureHandle_swigregister", RelinkableOptionletVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableOptionletVolatilityStructureHandle_swiginit", RelinkableOptionletVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "YoYOptionletVolatilitySurface_observationLag", _wrap_YoYOptionletVolatilitySurface_observationLag, METH_O, "YoYOptionletVolatilitySurface_observationLag(YoYOptionletVolatilitySurface self) -> Period"},
	 { "YoYOptionletVolatilitySurface_frequency", _wrap_YoYOptionletVolatilitySurface_frequency, METH_O, "YoYOptionletVolatilitySurface_frequency(YoYOptionletVolatilitySurface self) -> Real"},
	 { "YoYOptionletVolatilitySurface_indexIsInterpolated", _wrap_YoYOptionletVolatilitySurface_indexIsInterpolated, METH_O, "YoYOptionletVolatilitySurface_indexIsInterpolated(YoYOptionletVolatilitySurface self) -> bool"},
	 { "YoYOptionletVolatilitySurface_baseDate", _wrap_YoYOptionletVolatilitySurface_baseDate, METH_O, "YoYOptionletVolatilitySurface_baseDate(YoYOptionletVolatilitySurface self) -> Date"},
	 { "YoYOptionletVolatilitySurface_timeFromBase", _wrap_YoYOptionletVolatilitySurface_timeFromBase, METH_VARARGS, "YoYOptionletVolatilitySurface_timeFromBase(YoYOptionletVolatilitySurface self, Date date, Period obsLag=Period(-1,Days)) -> Time"},
	 { "YoYOptionletVolatilitySurface_minStrike", _wrap_YoYOptionletVolatilitySurface_minStrike, METH_O, "YoYOptionletVolatilitySurface_minStrike(YoYOptionletVolatilitySurface self) -> Real"},
	 { "YoYOptionletVolatilitySurface_maxStrike", _wrap_YoYOptionletVolatilitySurface_maxStrike, METH_O, "YoYOptionletVolatilitySurface_maxStrike(YoYOptionletVolatilitySurface self) -> Real"},
	 { "YoYOptionletVolatilitySurface_baseLevel", _wrap_YoYOptionletVolatilitySurface_baseLevel, METH_O, "YoYOptionletVolatilitySurface_baseLevel(YoYOptionletVolatilitySurface self) -> Volatility"},
	 { "YoYOptionletVolatilitySurface_volatility", _wrap_YoYOptionletVolatilitySurface_volatility, METH_VARARGS, "\n"
		"YoYOptionletVolatilitySurface_volatility(YoYOptionletVolatilitySurface self, Date maturityDate, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility\n"
		"YoYOptionletVolatilitySurface_volatility(YoYOptionletVolatilitySurface self, Period optionTenor, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility\n"
		""},
	 { "YoYOptionletVolatilitySurface_totalVariance", _wrap_YoYOptionletVolatilitySurface_totalVariance, METH_VARARGS, "\n"
		"YoYOptionletVolatilitySurface_totalVariance(YoYOptionletVolatilitySurface self, Date exerciseDate, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real\n"
		"YoYOptionletVolatilitySurface_totalVariance(YoYOptionletVolatilitySurface self, Period optionTenor, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real\n"
		""},
	 { "delete_YoYOptionletVolatilitySurface", _wrap_delete_YoYOptionletVolatilitySurface, METH_O, "delete_YoYOptionletVolatilitySurface(YoYOptionletVolatilitySurface self)"},
	 { "YoYOptionletVolatilitySurface_swigregister", YoYOptionletVolatilitySurface_swigregister, METH_O, NULL},
	 { "new_YoYOptionletVolatilitySurfaceHandle", _wrap_new_YoYOptionletVolatilitySurfaceHandle, METH_VARARGS, "YoYOptionletVolatilitySurfaceHandle(ext::shared_ptr< YoYOptionletVolatilitySurface > const & arg1=ext::shared_ptr())"},
	 { "YoYOptionletVolatilitySurfaceHandle___deref__", _wrap_YoYOptionletVolatilitySurfaceHandle___deref__, METH_O, "YoYOptionletVolatilitySurfaceHandle___deref__(YoYOptionletVolatilitySurfaceHandle self) -> ext::shared_ptr< YoYOptionletVolatilitySurface >"},
	 { "YoYOptionletVolatilitySurfaceHandle_currentLink", _wrap_YoYOptionletVolatilitySurfaceHandle_currentLink, METH_O, "YoYOptionletVolatilitySurfaceHandle_currentLink(YoYOptionletVolatilitySurfaceHandle self) -> ext::shared_ptr< YoYOptionletVolatilitySurface >"},
	 { "YoYOptionletVolatilitySurfaceHandle___nonzero__", _wrap_YoYOptionletVolatilitySurfaceHandle___nonzero__, METH_O, "YoYOptionletVolatilitySurfaceHandle___nonzero__(YoYOptionletVolatilitySurfaceHandle self) -> bool"},
	 { "YoYOptionletVolatilitySurfaceHandle___bool__", _wrap_YoYOptionletVolatilitySurfaceHandle___bool__, METH_O, "YoYOptionletVolatilitySurfaceHandle___bool__(YoYOptionletVolatilitySurfaceHandle self) -> bool"},
	 { "YoYOptionletVolatilitySurfaceHandle_asObservable", _wrap_YoYOptionletVolatilitySurfaceHandle_asObservable, METH_O, "YoYOptionletVolatilitySurfaceHandle_asObservable(YoYOptionletVolatilitySurfaceHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_YoYOptionletVolatilitySurfaceHandle", _wrap_delete_YoYOptionletVolatilitySurfaceHandle, METH_O, "delete_YoYOptionletVolatilitySurfaceHandle(YoYOptionletVolatilitySurfaceHandle self)"},
	 { "YoYOptionletVolatilitySurfaceHandle_observationLag", _wrap_YoYOptionletVolatilitySurfaceHandle_observationLag, METH_O, "YoYOptionletVolatilitySurfaceHandle_observationLag(YoYOptionletVolatilitySurfaceHandle self) -> Period"},
	 { "YoYOptionletVolatilitySurfaceHandle_frequency", _wrap_YoYOptionletVolatilitySurfaceHandle_frequency, METH_O, "YoYOptionletVolatilitySurfaceHandle_frequency(YoYOptionletVolatilitySurfaceHandle self) -> Real"},
	 { "YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated", _wrap_YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated, METH_O, "YoYOptionletVolatilitySurfaceHandle_indexIsInterpolated(YoYOptionletVolatilitySurfaceHandle self) -> bool"},
	 { "YoYOptionletVolatilitySurfaceHandle_baseDate", _wrap_YoYOptionletVolatilitySurfaceHandle_baseDate, METH_O, "YoYOptionletVolatilitySurfaceHandle_baseDate(YoYOptionletVolatilitySurfaceHandle self) -> Date"},
	 { "YoYOptionletVolatilitySurfaceHandle_timeFromBase", _wrap_YoYOptionletVolatilitySurfaceHandle_timeFromBase, METH_VARARGS, "YoYOptionletVolatilitySurfaceHandle_timeFromBase(YoYOptionletVolatilitySurfaceHandle self, Date date, Period obsLag=Period(-1,Days)) -> Time"},
	 { "YoYOptionletVolatilitySurfaceHandle_minStrike", _wrap_YoYOptionletVolatilitySurfaceHandle_minStrike, METH_O, "YoYOptionletVolatilitySurfaceHandle_minStrike(YoYOptionletVolatilitySurfaceHandle self) -> Real"},
	 { "YoYOptionletVolatilitySurfaceHandle_maxStrike", _wrap_YoYOptionletVolatilitySurfaceHandle_maxStrike, METH_O, "YoYOptionletVolatilitySurfaceHandle_maxStrike(YoYOptionletVolatilitySurfaceHandle self) -> Real"},
	 { "YoYOptionletVolatilitySurfaceHandle_baseLevel", _wrap_YoYOptionletVolatilitySurfaceHandle_baseLevel, METH_O, "YoYOptionletVolatilitySurfaceHandle_baseLevel(YoYOptionletVolatilitySurfaceHandle self) -> Volatility"},
	 { "YoYOptionletVolatilitySurfaceHandle_volatility", _wrap_YoYOptionletVolatilitySurfaceHandle_volatility, METH_VARARGS, "\n"
		"YoYOptionletVolatilitySurfaceHandle_volatility(YoYOptionletVolatilitySurfaceHandle self, Date maturityDate, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility\n"
		"YoYOptionletVolatilitySurfaceHandle_volatility(YoYOptionletVolatilitySurfaceHandle self, Period optionTenor, Real strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Volatility\n"
		""},
	 { "YoYOptionletVolatilitySurfaceHandle_totalVariance", _wrap_YoYOptionletVolatilitySurfaceHandle_totalVariance, METH_VARARGS, "\n"
		"YoYOptionletVolatilitySurfaceHandle_totalVariance(YoYOptionletVolatilitySurfaceHandle self, Date exerciseDate, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real\n"
		"YoYOptionletVolatilitySurfaceHandle_totalVariance(YoYOptionletVolatilitySurfaceHandle self, Period optionTenor, Rate strike, Period obsLag=Period(-1,Days), bool extrapolate=False) -> Real\n"
		""},
	 { "YoYOptionletVolatilitySurfaceHandle_dayCounter", _wrap_YoYOptionletVolatilitySurfaceHandle_dayCounter, METH_O, "YoYOptionletVolatilitySurfaceHandle_dayCounter(YoYOptionletVolatilitySurfaceHandle self) -> DayCounter"},
	 { "YoYOptionletVolatilitySurfaceHandle_timeFromReference", _wrap_YoYOptionletVolatilitySurfaceHandle_timeFromReference, METH_VARARGS, "YoYOptionletVolatilitySurfaceHandle_timeFromReference(YoYOptionletVolatilitySurfaceHandle self, Date date) -> Time"},
	 { "YoYOptionletVolatilitySurfaceHandle_calendar", _wrap_YoYOptionletVolatilitySurfaceHandle_calendar, METH_O, "YoYOptionletVolatilitySurfaceHandle_calendar(YoYOptionletVolatilitySurfaceHandle self) -> Calendar"},
	 { "YoYOptionletVolatilitySurfaceHandle_referenceDate", _wrap_YoYOptionletVolatilitySurfaceHandle_referenceDate, METH_O, "YoYOptionletVolatilitySurfaceHandle_referenceDate(YoYOptionletVolatilitySurfaceHandle self) -> Date"},
	 { "YoYOptionletVolatilitySurfaceHandle_maxDate", _wrap_YoYOptionletVolatilitySurfaceHandle_maxDate, METH_O, "YoYOptionletVolatilitySurfaceHandle_maxDate(YoYOptionletVolatilitySurfaceHandle self) -> Date"},
	 { "YoYOptionletVolatilitySurfaceHandle_maxTime", _wrap_YoYOptionletVolatilitySurfaceHandle_maxTime, METH_O, "YoYOptionletVolatilitySurfaceHandle_maxTime(YoYOptionletVolatilitySurfaceHandle self) -> Time"},
	 { "YoYOptionletVolatilitySurfaceHandle_enableExtrapolation", _wrap_YoYOptionletVolatilitySurfaceHandle_enableExtrapolation, METH_O, "YoYOptionletVolatilitySurfaceHandle_enableExtrapolation(YoYOptionletVolatilitySurfaceHandle self)"},
	 { "YoYOptionletVolatilitySurfaceHandle_disableExtrapolation", _wrap_YoYOptionletVolatilitySurfaceHandle_disableExtrapolation, METH_O, "YoYOptionletVolatilitySurfaceHandle_disableExtrapolation(YoYOptionletVolatilitySurfaceHandle self)"},
	 { "YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation", _wrap_YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation, METH_O, "YoYOptionletVolatilitySurfaceHandle_allowsExtrapolation(YoYOptionletVolatilitySurfaceHandle self) -> bool"},
	 { "YoYOptionletVolatilitySurfaceHandle_swigregister", YoYOptionletVolatilitySurfaceHandle_swigregister, METH_O, NULL},
	 { "YoYOptionletVolatilitySurfaceHandle_swiginit", YoYOptionletVolatilitySurfaceHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableYoYOptionletVolatilitySurfaceHandle", _wrap_new_RelinkableYoYOptionletVolatilitySurfaceHandle, METH_VARARGS, "RelinkableYoYOptionletVolatilitySurfaceHandle(ext::shared_ptr< YoYOptionletVolatilitySurface > const & arg1=ext::shared_ptr())"},
	 { "RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo", _wrap_RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo, METH_VARARGS, "RelinkableYoYOptionletVolatilitySurfaceHandle_linkTo(RelinkableYoYOptionletVolatilitySurfaceHandle self, ext::shared_ptr< YoYOptionletVolatilitySurface > const & arg2)"},
	 { "RelinkableYoYOptionletVolatilitySurfaceHandle_reset", _wrap_RelinkableYoYOptionletVolatilitySurfaceHandle_reset, METH_O, "RelinkableYoYOptionletVolatilitySurfaceHandle_reset(RelinkableYoYOptionletVolatilitySurfaceHandle self)"},
	 { "delete_RelinkableYoYOptionletVolatilitySurfaceHandle", _wrap_delete_RelinkableYoYOptionletVolatilitySurfaceHandle, METH_O, "delete_RelinkableYoYOptionletVolatilitySurfaceHandle(RelinkableYoYOptionletVolatilitySurfaceHandle self)"},
	 { "RelinkableYoYOptionletVolatilitySurfaceHandle_swigregister", RelinkableYoYOptionletVolatilitySurfaceHandle_swigregister, METH_O, NULL},
	 { "RelinkableYoYOptionletVolatilitySurfaceHandle_swiginit", RelinkableYoYOptionletVolatilitySurfaceHandle_swiginit, METH_VARARGS, NULL},
	 { "SmileSection_minStrike", _wrap_SmileSection_minStrike, METH_O, "SmileSection_minStrike(SmileSection self) -> Real"},
	 { "SmileSection_maxStrike", _wrap_SmileSection_maxStrike, METH_O, "SmileSection_maxStrike(SmileSection self) -> Real"},
	 { "SmileSection_atmLevel", _wrap_SmileSection_atmLevel, METH_O, "SmileSection_atmLevel(SmileSection self) -> Real"},
	 { "SmileSection_variance", _wrap_SmileSection_variance, METH_VARARGS, "SmileSection_variance(SmileSection self, Rate strike) -> Real"},
	 { "SmileSection_exerciseDate", _wrap_SmileSection_exerciseDate, METH_O, "SmileSection_exerciseDate(SmileSection self) -> Date"},
	 { "SmileSection_volatilityType", _wrap_SmileSection_volatilityType, METH_O, "SmileSection_volatilityType(SmileSection self) -> VolatilityType"},
	 { "SmileSection_shift", _wrap_SmileSection_shift, METH_O, "SmileSection_shift(SmileSection self) -> Rate"},
	 { "SmileSection_referenceDate", _wrap_SmileSection_referenceDate, METH_O, "SmileSection_referenceDate(SmileSection self) -> Date"},
	 { "SmileSection_exerciseTime", _wrap_SmileSection_exerciseTime, METH_O, "SmileSection_exerciseTime(SmileSection self) -> Time"},
	 { "SmileSection_dayCounter", _wrap_SmileSection_dayCounter, METH_O, "SmileSection_dayCounter(SmileSection self) -> DayCounter"},
	 { "SmileSection_optionPrice", _wrap_SmileSection_optionPrice, METH_VARARGS, "SmileSection_optionPrice(SmileSection self, Rate strike, Option::Type type=Call, Real discount=1.0) -> Real"},
	 { "SmileSection_digitalOptionPrice", _wrap_SmileSection_digitalOptionPrice, METH_VARARGS, "SmileSection_digitalOptionPrice(SmileSection self, Rate strike, Option::Type type=Call, Real discount=1.0, Real gap=1.0e-5) -> Real"},
	 { "SmileSection_vega", _wrap_SmileSection_vega, METH_VARARGS, "SmileSection_vega(SmileSection self, Rate strike, Real discount=1.0) -> Real"},
	 { "SmileSection_density", _wrap_SmileSection_density, METH_VARARGS, "SmileSection_density(SmileSection self, Rate strike, Real discount=1.0, Real gap=1.0E-4) -> Real"},
	 { "SmileSection_volatility", _wrap_SmileSection_volatility, METH_VARARGS, "\n"
		"SmileSection_volatility(SmileSection self, Rate strike) -> Volatility\n"
		"SmileSection_volatility(SmileSection self, Rate strike, VolatilityType type, Real shift=0.0) -> Volatility\n"
		""},
	 { "delete_SmileSection", _wrap_delete_SmileSection, METH_O, "delete_SmileSection(SmileSection self)"},
	 { "SmileSection_swigregister", SmileSection_swigregister, METH_O, NULL},
	 { "SmileSectionVector_iterator", _wrap_SmileSectionVector_iterator, METH_O, "SmileSectionVector_iterator(SmileSectionVector self) -> SwigPyIterator"},
	 { "SmileSectionVector___nonzero__", _wrap_SmileSectionVector___nonzero__, METH_O, "SmileSectionVector___nonzero__(SmileSectionVector self) -> bool"},
	 { "SmileSectionVector___bool__", _wrap_SmileSectionVector___bool__, METH_O, "SmileSectionVector___bool__(SmileSectionVector self) -> bool"},
	 { "SmileSectionVector___len__", _wrap_SmileSectionVector___len__, METH_O, "SmileSectionVector___len__(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::size_type"},
	 { "SmileSectionVector___getslice__", _wrap_SmileSectionVector___getslice__, METH_VARARGS, "SmileSectionVector___getslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j) -> SmileSectionVector"},
	 { "SmileSectionVector___setslice__", _wrap_SmileSectionVector___setslice__, METH_VARARGS, "\n"
		"SmileSectionVector___setslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j)\n"
		"SmileSectionVector___setslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j, SmileSectionVector v)\n"
		""},
	 { "SmileSectionVector___delslice__", _wrap_SmileSectionVector___delslice__, METH_VARARGS, "SmileSectionVector___delslice__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::difference_type j)"},
	 { "SmileSectionVector___delitem__", _wrap_SmileSectionVector___delitem__, METH_VARARGS, "\n"
		"SmileSectionVector___delitem__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i)\n"
		"SmileSectionVector___delitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "SmileSectionVector___getitem__", _wrap_SmileSectionVector___getitem__, METH_VARARGS, "\n"
		"SmileSectionVector___getitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice) -> SmileSectionVector\n"
		"SmileSectionVector___getitem__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i) -> std::vector< ext::shared_ptr< SmileSection > >::value_type const &\n"
		""},
	 { "SmileSectionVector___setitem__", _wrap_SmileSectionVector___setitem__, METH_VARARGS, "\n"
		"SmileSectionVector___setitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice, SmileSectionVector v)\n"
		"SmileSectionVector___setitem__(SmileSectionVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"SmileSectionVector___setitem__(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::difference_type i, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)\n"
		""},
	 { "SmileSectionVector_pop", _wrap_SmileSectionVector_pop, METH_O, "SmileSectionVector_pop(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::value_type"},
	 { "SmileSectionVector_append", _wrap_SmileSectionVector_append, METH_VARARGS, "SmileSectionVector_append(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)"},
	 { "SmileSectionVector_empty", _wrap_SmileSectionVector_empty, METH_O, "SmileSectionVector_empty(SmileSectionVector self) -> bool"},
	 { "SmileSectionVector_size", _wrap_SmileSectionVector_size, METH_O, "SmileSectionVector_size(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::size_type"},
	 { "SmileSectionVector_swap", _wrap_SmileSectionVector_swap, METH_VARARGS, "SmileSectionVector_swap(SmileSectionVector self, SmileSectionVector v)"},
	 { "SmileSectionVector_begin", _wrap_SmileSectionVector_begin, METH_O, "SmileSectionVector_begin(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::iterator"},
	 { "SmileSectionVector_end", _wrap_SmileSectionVector_end, METH_O, "SmileSectionVector_end(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::iterator"},
	 { "SmileSectionVector_rbegin", _wrap_SmileSectionVector_rbegin, METH_O, "SmileSectionVector_rbegin(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator"},
	 { "SmileSectionVector_rend", _wrap_SmileSectionVector_rend, METH_O, "SmileSectionVector_rend(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::reverse_iterator"},
	 { "SmileSectionVector_clear", _wrap_SmileSectionVector_clear, METH_O, "SmileSectionVector_clear(SmileSectionVector self)"},
	 { "SmileSectionVector_get_allocator", _wrap_SmileSectionVector_get_allocator, METH_O, "SmileSectionVector_get_allocator(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::allocator_type"},
	 { "SmileSectionVector_pop_back", _wrap_SmileSectionVector_pop_back, METH_O, "SmileSectionVector_pop_back(SmileSectionVector self)"},
	 { "SmileSectionVector_erase", _wrap_SmileSectionVector_erase, METH_VARARGS, "\n"
		"SmileSectionVector_erase(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator pos) -> std::vector< ext::shared_ptr< SmileSection > >::iterator\n"
		"SmileSectionVector_erase(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator first, std::vector< ext::shared_ptr< SmileSection > >::iterator last) -> std::vector< ext::shared_ptr< SmileSection > >::iterator\n"
		""},
	 { "new_SmileSectionVector", _wrap_new_SmileSectionVector, METH_VARARGS, "\n"
		"SmileSectionVector()\n"
		"SmileSectionVector(SmileSectionVector other)\n"
		"SmileSectionVector(std::vector< ext::shared_ptr< SmileSection > >::size_type size)\n"
		"new_SmileSectionVector(std::vector< ext::shared_ptr< SmileSection > >::size_type size, std::vector< ext::shared_ptr< SmileSection > >::value_type const & value) -> SmileSectionVector\n"
		""},
	 { "SmileSectionVector_push_back", _wrap_SmileSectionVector_push_back, METH_VARARGS, "SmileSectionVector_push_back(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)"},
	 { "SmileSectionVector_front", _wrap_SmileSectionVector_front, METH_O, "SmileSectionVector_front(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::value_type const &"},
	 { "SmileSectionVector_back", _wrap_SmileSectionVector_back, METH_O, "SmileSectionVector_back(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::value_type const &"},
	 { "SmileSectionVector_assign", _wrap_SmileSectionVector_assign, METH_VARARGS, "SmileSectionVector_assign(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type n, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)"},
	 { "SmileSectionVector_resize", _wrap_SmileSectionVector_resize, METH_VARARGS, "\n"
		"SmileSectionVector_resize(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type new_size)\n"
		"SmileSectionVector_resize(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type new_size, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)\n"
		""},
	 { "SmileSectionVector_insert", _wrap_SmileSectionVector_insert, METH_VARARGS, "\n"
		"SmileSectionVector_insert(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator pos, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x) -> std::vector< ext::shared_ptr< SmileSection > >::iterator\n"
		"SmileSectionVector_insert(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::iterator pos, std::vector< ext::shared_ptr< SmileSection > >::size_type n, std::vector< ext::shared_ptr< SmileSection > >::value_type const & x)\n"
		""},
	 { "SmileSectionVector_reserve", _wrap_SmileSectionVector_reserve, METH_VARARGS, "SmileSectionVector_reserve(SmileSectionVector self, std::vector< ext::shared_ptr< SmileSection > >::size_type n)"},
	 { "SmileSectionVector_capacity", _wrap_SmileSectionVector_capacity, METH_O, "SmileSectionVector_capacity(SmileSectionVector self) -> std::vector< ext::shared_ptr< SmileSection > >::size_type"},
	 { "delete_SmileSectionVector", _wrap_delete_SmileSectionVector, METH_O, "delete_SmileSectionVector(SmileSectionVector self)"},
	 { "SmileSectionVector_swigregister", SmileSectionVector_swigregister, METH_O, NULL},
	 { "SmileSectionVector_swiginit", SmileSectionVector_swiginit, METH_VARARGS, NULL},
	 { "SwaptionVolatilityStructure_volatility", _wrap_SwaptionVolatilityStructure_volatility, METH_VARARGS, "\n"
		"SwaptionVolatilityStructure_volatility(SwaptionVolatilityStructure self, Date start, Period length, Rate strike, bool extrapolate=False) -> Volatility\n"
		"SwaptionVolatilityStructure_volatility(SwaptionVolatilityStructure self, Time start, Time length, Rate strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "SwaptionVolatilityStructure_blackVariance", _wrap_SwaptionVolatilityStructure_blackVariance, METH_VARARGS, "\n"
		"SwaptionVolatilityStructure_blackVariance(SwaptionVolatilityStructure self, Date start, Period length, Rate strike, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructure_blackVariance(SwaptionVolatilityStructure self, Time start, Time length, Rate strike, bool extrapolate=False) -> Real\n"
		""},
	 { "SwaptionVolatilityStructure_optionDateFromTenor", _wrap_SwaptionVolatilityStructure_optionDateFromTenor, METH_VARARGS, "SwaptionVolatilityStructure_optionDateFromTenor(SwaptionVolatilityStructure self, Period p) -> Date"},
	 { "SwaptionVolatilityStructure_shift", _wrap_SwaptionVolatilityStructure_shift, METH_VARARGS, "\n"
		"SwaptionVolatilityStructure_shift(SwaptionVolatilityStructure self, Period optionTenor, Period swapTenor, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructure_shift(SwaptionVolatilityStructure self, Date optionDate, Period swapTenor, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructure_shift(SwaptionVolatilityStructure self, Time optionTime, Period swapTenor, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructure_shift(SwaptionVolatilityStructure self, Period optionTenor, Time swapLength, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructure_shift(SwaptionVolatilityStructure self, Date optionDate, Time swapLength, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructure_shift(SwaptionVolatilityStructure self, Time optionTime, Time swapLength, bool extrapolate=False) -> Real\n"
		""},
	 { "SwaptionVolatilityStructure_smileSection", _wrap_SwaptionVolatilityStructure_smileSection, METH_VARARGS, "\n"
		"SwaptionVolatilityStructure_smileSection(SwaptionVolatilityStructure self, Period optionTenor, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructure_smileSection(SwaptionVolatilityStructure self, Date optionDate, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructure_smileSection(SwaptionVolatilityStructure self, Time optionTime, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructure_smileSection(SwaptionVolatilityStructure self, Period optionTenor, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructure_smileSection(SwaptionVolatilityStructure self, Date optionDate, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructure_smileSection(SwaptionVolatilityStructure self, Time optionTime, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		""},
	 { "delete_SwaptionVolatilityStructure", _wrap_delete_SwaptionVolatilityStructure, METH_O, "delete_SwaptionVolatilityStructure(SwaptionVolatilityStructure self)"},
	 { "SwaptionVolatilityStructure_swigregister", SwaptionVolatilityStructure_swigregister, METH_O, NULL},
	 { "new_SwaptionVolatilityStructureHandle", _wrap_new_SwaptionVolatilityStructureHandle, METH_VARARGS, "SwaptionVolatilityStructureHandle(ext::shared_ptr< SwaptionVolatilityStructure > const & arg1=ext::shared_ptr())"},
	 { "SwaptionVolatilityStructureHandle___deref__", _wrap_SwaptionVolatilityStructureHandle___deref__, METH_O, "SwaptionVolatilityStructureHandle___deref__(SwaptionVolatilityStructureHandle self) -> ext::shared_ptr< SwaptionVolatilityStructure >"},
	 { "SwaptionVolatilityStructureHandle_currentLink", _wrap_SwaptionVolatilityStructureHandle_currentLink, METH_O, "SwaptionVolatilityStructureHandle_currentLink(SwaptionVolatilityStructureHandle self) -> ext::shared_ptr< SwaptionVolatilityStructure >"},
	 { "SwaptionVolatilityStructureHandle___nonzero__", _wrap_SwaptionVolatilityStructureHandle___nonzero__, METH_O, "SwaptionVolatilityStructureHandle___nonzero__(SwaptionVolatilityStructureHandle self) -> bool"},
	 { "SwaptionVolatilityStructureHandle___bool__", _wrap_SwaptionVolatilityStructureHandle___bool__, METH_O, "SwaptionVolatilityStructureHandle___bool__(SwaptionVolatilityStructureHandle self) -> bool"},
	 { "SwaptionVolatilityStructureHandle_asObservable", _wrap_SwaptionVolatilityStructureHandle_asObservable, METH_O, "SwaptionVolatilityStructureHandle_asObservable(SwaptionVolatilityStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_SwaptionVolatilityStructureHandle", _wrap_delete_SwaptionVolatilityStructureHandle, METH_O, "delete_SwaptionVolatilityStructureHandle(SwaptionVolatilityStructureHandle self)"},
	 { "SwaptionVolatilityStructureHandle_volatility", _wrap_SwaptionVolatilityStructureHandle_volatility, METH_VARARGS, "\n"
		"SwaptionVolatilityStructureHandle_volatility(SwaptionVolatilityStructureHandle self, Date start, Period length, Rate strike, bool extrapolate=False) -> Volatility\n"
		"SwaptionVolatilityStructureHandle_volatility(SwaptionVolatilityStructureHandle self, Time start, Time length, Rate strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "SwaptionVolatilityStructureHandle_blackVariance", _wrap_SwaptionVolatilityStructureHandle_blackVariance, METH_VARARGS, "\n"
		"SwaptionVolatilityStructureHandle_blackVariance(SwaptionVolatilityStructureHandle self, Date start, Period length, Rate strike, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructureHandle_blackVariance(SwaptionVolatilityStructureHandle self, Time start, Time length, Rate strike, bool extrapolate=False) -> Real\n"
		""},
	 { "SwaptionVolatilityStructureHandle_optionDateFromTenor", _wrap_SwaptionVolatilityStructureHandle_optionDateFromTenor, METH_VARARGS, "SwaptionVolatilityStructureHandle_optionDateFromTenor(SwaptionVolatilityStructureHandle self, Period p) -> Date"},
	 { "SwaptionVolatilityStructureHandle_shift", _wrap_SwaptionVolatilityStructureHandle_shift, METH_VARARGS, "\n"
		"SwaptionVolatilityStructureHandle_shift(SwaptionVolatilityStructureHandle self, Period optionTenor, Period swapTenor, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructureHandle_shift(SwaptionVolatilityStructureHandle self, Date optionDate, Period swapTenor, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructureHandle_shift(SwaptionVolatilityStructureHandle self, Time optionTime, Period swapTenor, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructureHandle_shift(SwaptionVolatilityStructureHandle self, Period optionTenor, Time swapLength, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructureHandle_shift(SwaptionVolatilityStructureHandle self, Date optionDate, Time swapLength, bool extrapolate=False) -> Real\n"
		"SwaptionVolatilityStructureHandle_shift(SwaptionVolatilityStructureHandle self, Time optionTime, Time swapLength, bool extrapolate=False) -> Real\n"
		""},
	 { "SwaptionVolatilityStructureHandle_smileSection", _wrap_SwaptionVolatilityStructureHandle_smileSection, METH_VARARGS, "\n"
		"SwaptionVolatilityStructureHandle_smileSection(SwaptionVolatilityStructureHandle self, Period optionTenor, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructureHandle_smileSection(SwaptionVolatilityStructureHandle self, Date optionDate, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructureHandle_smileSection(SwaptionVolatilityStructureHandle self, Time optionTime, Period swapTenor, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructureHandle_smileSection(SwaptionVolatilityStructureHandle self, Period optionTenor, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructureHandle_smileSection(SwaptionVolatilityStructureHandle self, Date optionDate, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		"SwaptionVolatilityStructureHandle_smileSection(SwaptionVolatilityStructureHandle self, Time optionTime, Time swapLength, bool extr=False) -> ext::shared_ptr< SmileSection >\n"
		""},
	 { "SwaptionVolatilityStructureHandle_minStrike", _wrap_SwaptionVolatilityStructureHandle_minStrike, METH_O, "SwaptionVolatilityStructureHandle_minStrike(SwaptionVolatilityStructureHandle self) -> Real"},
	 { "SwaptionVolatilityStructureHandle_maxStrike", _wrap_SwaptionVolatilityStructureHandle_maxStrike, METH_O, "SwaptionVolatilityStructureHandle_maxStrike(SwaptionVolatilityStructureHandle self) -> Real"},
	 { "SwaptionVolatilityStructureHandle_dayCounter", _wrap_SwaptionVolatilityStructureHandle_dayCounter, METH_O, "SwaptionVolatilityStructureHandle_dayCounter(SwaptionVolatilityStructureHandle self) -> DayCounter"},
	 { "SwaptionVolatilityStructureHandle_timeFromReference", _wrap_SwaptionVolatilityStructureHandle_timeFromReference, METH_VARARGS, "SwaptionVolatilityStructureHandle_timeFromReference(SwaptionVolatilityStructureHandle self, Date date) -> Time"},
	 { "SwaptionVolatilityStructureHandle_calendar", _wrap_SwaptionVolatilityStructureHandle_calendar, METH_O, "SwaptionVolatilityStructureHandle_calendar(SwaptionVolatilityStructureHandle self) -> Calendar"},
	 { "SwaptionVolatilityStructureHandle_referenceDate", _wrap_SwaptionVolatilityStructureHandle_referenceDate, METH_O, "SwaptionVolatilityStructureHandle_referenceDate(SwaptionVolatilityStructureHandle self) -> Date"},
	 { "SwaptionVolatilityStructureHandle_maxDate", _wrap_SwaptionVolatilityStructureHandle_maxDate, METH_O, "SwaptionVolatilityStructureHandle_maxDate(SwaptionVolatilityStructureHandle self) -> Date"},
	 { "SwaptionVolatilityStructureHandle_maxTime", _wrap_SwaptionVolatilityStructureHandle_maxTime, METH_O, "SwaptionVolatilityStructureHandle_maxTime(SwaptionVolatilityStructureHandle self) -> Time"},
	 { "SwaptionVolatilityStructureHandle_enableExtrapolation", _wrap_SwaptionVolatilityStructureHandle_enableExtrapolation, METH_O, "SwaptionVolatilityStructureHandle_enableExtrapolation(SwaptionVolatilityStructureHandle self)"},
	 { "SwaptionVolatilityStructureHandle_disableExtrapolation", _wrap_SwaptionVolatilityStructureHandle_disableExtrapolation, METH_O, "SwaptionVolatilityStructureHandle_disableExtrapolation(SwaptionVolatilityStructureHandle self)"},
	 { "SwaptionVolatilityStructureHandle_allowsExtrapolation", _wrap_SwaptionVolatilityStructureHandle_allowsExtrapolation, METH_O, "SwaptionVolatilityStructureHandle_allowsExtrapolation(SwaptionVolatilityStructureHandle self) -> bool"},
	 { "SwaptionVolatilityStructureHandle_swigregister", SwaptionVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "SwaptionVolatilityStructureHandle_swiginit", SwaptionVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableSwaptionVolatilityStructureHandle", _wrap_new_RelinkableSwaptionVolatilityStructureHandle, METH_VARARGS, "RelinkableSwaptionVolatilityStructureHandle(ext::shared_ptr< SwaptionVolatilityStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableSwaptionVolatilityStructureHandle_linkTo", _wrap_RelinkableSwaptionVolatilityStructureHandle_linkTo, METH_VARARGS, "RelinkableSwaptionVolatilityStructureHandle_linkTo(RelinkableSwaptionVolatilityStructureHandle self, ext::shared_ptr< SwaptionVolatilityStructure > const & arg2)"},
	 { "RelinkableSwaptionVolatilityStructureHandle_reset", _wrap_RelinkableSwaptionVolatilityStructureHandle_reset, METH_O, "RelinkableSwaptionVolatilityStructureHandle_reset(RelinkableSwaptionVolatilityStructureHandle self)"},
	 { "delete_RelinkableSwaptionVolatilityStructureHandle", _wrap_delete_RelinkableSwaptionVolatilityStructureHandle, METH_O, "delete_RelinkableSwaptionVolatilityStructureHandle(RelinkableSwaptionVolatilityStructureHandle self)"},
	 { "RelinkableSwaptionVolatilityStructureHandle_swigregister", RelinkableSwaptionVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableSwaptionVolatilityStructureHandle_swiginit", RelinkableSwaptionVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_BlackConstantVol", _wrap_new_BlackConstantVol, METH_VARARGS, "\n"
		"BlackConstantVol(Date referenceDate, Calendar c, Volatility volatility, DayCounter dayCounter)\n"
		"BlackConstantVol(Date referenceDate, Calendar c, QuoteHandle volatility, DayCounter dayCounter)\n"
		"BlackConstantVol(Natural settlementDays, Calendar calendar, Volatility volatility, DayCounter dayCounter)\n"
		"new_BlackConstantVol(Natural settlementDays, Calendar calendar, QuoteHandle volatility, DayCounter dayCounter) -> BlackConstantVol\n"
		""},
	 { "delete_BlackConstantVol", _wrap_delete_BlackConstantVol, METH_O, "delete_BlackConstantVol(BlackConstantVol self)"},
	 { "BlackConstantVol_swigregister", BlackConstantVol_swigregister, METH_O, NULL},
	 { "BlackConstantVol_swiginit", BlackConstantVol_swiginit, METH_VARARGS, NULL},
	 { "new_BlackVarianceCurve", _wrap_new_BlackVarianceCurve, METH_VARARGS, "BlackVarianceCurve(Date referenceDate, DateVector dates, DoubleVector volatilities, DayCounter dayCounter, bool forceMonotoneVariance=True)"},
	 { "delete_BlackVarianceCurve", _wrap_delete_BlackVarianceCurve, METH_O, "delete_BlackVarianceCurve(BlackVarianceCurve self)"},
	 { "BlackVarianceCurve_swigregister", BlackVarianceCurve_swigregister, METH_O, NULL},
	 { "BlackVarianceCurve_swiginit", BlackVarianceCurve_swiginit, METH_VARARGS, NULL},
	 { "new_BlackVarianceSurface", (PyCFunction)(void(*)(void))_wrap_new_BlackVarianceSurface, METH_VARARGS|METH_KEYWORDS, "new_BlackVarianceSurface(Date referenceDate, Calendar cal, DateVector dates, DoubleVector strikes, Matrix blackVols, DayCounter dayCounter, BlackVarianceSurface::Extrapolation lower=InterpolatorDefaultExtrapolation, BlackVarianceSurface::Extrapolation upper=InterpolatorDefaultExtrapolation, std::string const & interpolator=\"\") -> BlackVarianceSurface"},
	 { "BlackVarianceSurface_setInterpolation", _wrap_BlackVarianceSurface_setInterpolation, METH_VARARGS, "BlackVarianceSurface_setInterpolation(BlackVarianceSurface self, std::string const & interpolator=\"\")"},
	 { "delete_BlackVarianceSurface", _wrap_delete_BlackVarianceSurface, METH_O, "delete_BlackVarianceSurface(BlackVarianceSurface self)"},
	 { "BlackVarianceSurface_swigregister", BlackVarianceSurface_swigregister, METH_O, NULL},
	 { "BlackVarianceSurface_swiginit", BlackVarianceSurface_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantOptionletVolatility", _wrap_new_ConstantOptionletVolatility, METH_VARARGS, "\n"
		"ConstantOptionletVolatility(Date referenceDate, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"ConstantOptionletVolatility(Date referenceDate, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"ConstantOptionletVolatility(Natural settlementDays, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"ConstantOptionletVolatility(Natural settlementDays, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dayCounter, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "delete_ConstantOptionletVolatility", _wrap_delete_ConstantOptionletVolatility, METH_O, "delete_ConstantOptionletVolatility(ConstantOptionletVolatility self)"},
	 { "ConstantOptionletVolatility_swigregister", ConstantOptionletVolatility_swigregister, METH_O, NULL},
	 { "ConstantOptionletVolatility_swiginit", ConstantOptionletVolatility_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantSwaptionVolatility", _wrap_new_ConstantSwaptionVolatility, METH_VARARGS, "\n"
		"ConstantSwaptionVolatility(Natural settlementDays, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"ConstantSwaptionVolatility(Date referenceDate, Calendar cal, BusinessDayConvention bdc, QuoteHandle volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"ConstantSwaptionVolatility(Natural settlementDays, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"ConstantSwaptionVolatility(Date referenceDate, Calendar cal, BusinessDayConvention bdc, Volatility volatility, DayCounter dc, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "delete_ConstantSwaptionVolatility", _wrap_delete_ConstantSwaptionVolatility, METH_O, "delete_ConstantSwaptionVolatility(ConstantSwaptionVolatility self)"},
	 { "ConstantSwaptionVolatility_swigregister", ConstantSwaptionVolatility_swigregister, METH_O, NULL},
	 { "ConstantSwaptionVolatility_swiginit", ConstantSwaptionVolatility_swiginit, METH_VARARGS, NULL},
	 { "SwaptionVolatilityDiscrete_optionTenors", _wrap_SwaptionVolatilityDiscrete_optionTenors, METH_O, "SwaptionVolatilityDiscrete_optionTenors(SwaptionVolatilityDiscrete self) -> PeriodVector"},
	 { "SwaptionVolatilityDiscrete_optionDates", _wrap_SwaptionVolatilityDiscrete_optionDates, METH_O, "SwaptionVolatilityDiscrete_optionDates(SwaptionVolatilityDiscrete self) -> DateVector"},
	 { "SwaptionVolatilityDiscrete_optionTimes", _wrap_SwaptionVolatilityDiscrete_optionTimes, METH_O, "SwaptionVolatilityDiscrete_optionTimes(SwaptionVolatilityDiscrete self) -> DoubleVector"},
	 { "SwaptionVolatilityDiscrete_swapTenors", _wrap_SwaptionVolatilityDiscrete_swapTenors, METH_O, "SwaptionVolatilityDiscrete_swapTenors(SwaptionVolatilityDiscrete self) -> PeriodVector"},
	 { "SwaptionVolatilityDiscrete_swapLengths", _wrap_SwaptionVolatilityDiscrete_swapLengths, METH_O, "SwaptionVolatilityDiscrete_swapLengths(SwaptionVolatilityDiscrete self) -> DoubleVector"},
	 { "SwaptionVolatilityDiscrete_optionDateFromTime", _wrap_SwaptionVolatilityDiscrete_optionDateFromTime, METH_VARARGS, "SwaptionVolatilityDiscrete_optionDateFromTime(SwaptionVolatilityDiscrete self, Time optionTime) -> Date"},
	 { "delete_SwaptionVolatilityDiscrete", _wrap_delete_SwaptionVolatilityDiscrete, METH_O, "delete_SwaptionVolatilityDiscrete(SwaptionVolatilityDiscrete self)"},
	 { "SwaptionVolatilityDiscrete_swigregister", SwaptionVolatilityDiscrete_swigregister, METH_O, NULL},
	 { "new_SwaptionVolatilityMatrix", _wrap_new_SwaptionVolatilityMatrix, METH_VARARGS, "\n"
		"SwaptionVolatilityMatrix(Date referenceDate, Calendar calendar, BusinessDayConvention bdc, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, Matrix shifts=Matrix())\n"
		"SwaptionVolatilityMatrix(Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, PeriodVector swapTenors, QuoteHandleVectorVector vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, DoubleVectorVector shifts=std::vector< std::vector< Real > >())\n"
		"SwaptionVolatilityMatrix(Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, PeriodVector swapTenors, Matrix vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, Matrix shifts=Matrix())\n"
		"SwaptionVolatilityMatrix(Date referenceDate, DateVector dates, PeriodVector lengths, Matrix vols, DayCounter dayCounter, bool const flatExtrapolation=False, VolatilityType const type=ShiftedLognormal, Matrix shifts=Matrix())\n"
		""},
	 { "SwaptionVolatilityMatrix_locate", _wrap_SwaptionVolatilityMatrix_locate, METH_VARARGS, "\n"
		"SwaptionVolatilityMatrix_locate(SwaptionVolatilityMatrix self, Date optionDate, Period swapTenor) -> UnsignedIntPair\n"
		"SwaptionVolatilityMatrix_locate(SwaptionVolatilityMatrix self, Time optionTime, Time swapLength) -> UnsignedIntPair\n"
		""},
	 { "SwaptionVolatilityMatrix_volatilityType", _wrap_SwaptionVolatilityMatrix_volatilityType, METH_O, "SwaptionVolatilityMatrix_volatilityType(SwaptionVolatilityMatrix self) -> VolatilityType"},
	 { "delete_SwaptionVolatilityMatrix", _wrap_delete_SwaptionVolatilityMatrix, METH_O, "delete_SwaptionVolatilityMatrix(SwaptionVolatilityMatrix self)"},
	 { "SwaptionVolatilityMatrix_swigregister", SwaptionVolatilityMatrix_swigregister, METH_O, NULL},
	 { "SwaptionVolatilityMatrix_swiginit", SwaptionVolatilityMatrix_swiginit, METH_VARARGS, NULL},
	 { "new_SabrSmileSection", _wrap_new_SabrSmileSection, METH_VARARGS, "\n"
		"SabrSmileSection(Date d, Rate forward, DoubleVector sabrParameters, Date referenceDate=Date(), DayCounter dc=Actual365Fixed(), Real shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal)\n"
		"SabrSmileSection(Time timeToExpiry, Rate forward, DoubleVector sabrParameters, Real shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal)\n"
		""},
	 { "SabrSmileSection_alpha", _wrap_SabrSmileSection_alpha, METH_O, "SabrSmileSection_alpha(SabrSmileSection self) -> Real"},
	 { "SabrSmileSection_beta", _wrap_SabrSmileSection_beta, METH_O, "SabrSmileSection_beta(SabrSmileSection self) -> Real"},
	 { "SabrSmileSection_nu", _wrap_SabrSmileSection_nu, METH_O, "SabrSmileSection_nu(SabrSmileSection self) -> Real"},
	 { "SabrSmileSection_rho", _wrap_SabrSmileSection_rho, METH_O, "SabrSmileSection_rho(SabrSmileSection self) -> Real"},
	 { "delete_SabrSmileSection", _wrap_delete_SabrSmileSection, METH_O, "delete_SabrSmileSection(SabrSmileSection self)"},
	 { "SabrSmileSection_swigregister", SabrSmileSection_swigregister, METH_O, NULL},
	 { "SabrSmileSection_swiginit", SabrSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_SviSmileSection", _wrap_new_SviSmileSection, METH_VARARGS, "\n"
		"SviSmileSection(Time timeToExpiry, Rate forward, DoubleVector sviParameters)\n"
		"SviSmileSection(Date d, Rate forward, DoubleVector sviParameters, DayCounter dc=Actual365Fixed())\n"
		""},
	 { "delete_SviSmileSection", _wrap_delete_SviSmileSection, METH_O, "delete_SviSmileSection(SviSmileSection self)"},
	 { "SviSmileSection_swigregister", SviSmileSection_swigregister, METH_O, NULL},
	 { "SviSmileSection_swiginit", SviSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_SviInterpolatedSmileSection", _wrap_new_SviInterpolatedSmileSection, METH_VARARGS, "\n"
		"SviInterpolatedSmileSection(Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real a, Real b, Real sigma, Real rho, Real m, bool aIsFixed, bool bIsFixed, bool sigmaIsFixed, bool rhoIsFixed, bool mIsFixed, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		"SviInterpolatedSmileSection(Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real a, Real b, Real sigma, Real rho, Real m, bool isAFixed, bool isBFixed, bool isSigmaFixed, bool isRhoFixed, bool isMFixed, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		""},
	 { "SviInterpolatedSmileSection_a", _wrap_SviInterpolatedSmileSection_a, METH_O, "SviInterpolatedSmileSection_a(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_b", _wrap_SviInterpolatedSmileSection_b, METH_O, "SviInterpolatedSmileSection_b(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_sigma", _wrap_SviInterpolatedSmileSection_sigma, METH_O, "SviInterpolatedSmileSection_sigma(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_rho", _wrap_SviInterpolatedSmileSection_rho, METH_O, "SviInterpolatedSmileSection_rho(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_m", _wrap_SviInterpolatedSmileSection_m, METH_O, "SviInterpolatedSmileSection_m(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_rmsError", _wrap_SviInterpolatedSmileSection_rmsError, METH_O, "SviInterpolatedSmileSection_rmsError(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_maxError", _wrap_SviInterpolatedSmileSection_maxError, METH_O, "SviInterpolatedSmileSection_maxError(SviInterpolatedSmileSection self) -> Real"},
	 { "SviInterpolatedSmileSection_endCriteria", _wrap_SviInterpolatedSmileSection_endCriteria, METH_O, "SviInterpolatedSmileSection_endCriteria(SviInterpolatedSmileSection self) -> EndCriteria::Type"},
	 { "delete_SviInterpolatedSmileSection", _wrap_delete_SviInterpolatedSmileSection, METH_O, "delete_SviInterpolatedSmileSection(SviInterpolatedSmileSection self)"},
	 { "SviInterpolatedSmileSection_swigregister", SviInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "SviInterpolatedSmileSection_swiginit", SviInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "SwaptionVolatilityCube_atmStrike", _wrap_SwaptionVolatilityCube_atmStrike, METH_VARARGS, "SwaptionVolatilityCube_atmStrike(SwaptionVolatilityCube self, Date optionDate, Period swapTenor) -> Rate"},
	 { "delete_SwaptionVolatilityCube", _wrap_delete_SwaptionVolatilityCube, METH_O, "delete_SwaptionVolatilityCube(SwaptionVolatilityCube self)"},
	 { "SwaptionVolatilityCube_swigregister", SwaptionVolatilityCube_swigregister, METH_O, NULL},
	 { "new_SabrSwaptionVolatilityCube", _wrap_new_SabrSwaptionVolatilityCube, METH_VARARGS, "SabrSwaptionVolatilityCube(SwaptionVolatilityStructureHandle atmVolStructure, PeriodVector optionTenors, PeriodVector swapTenors, DoubleVector strikeSpreads, QuoteHandleVectorVector volSpreads, ext::shared_ptr< SwapIndex > const & swapIndex, ext::shared_ptr< SwapIndex > const & shortSwapIndex, bool vegaWeightedSmileFit, QuoteHandleVectorVector parametersGuess, BoolVector isParameterFixed, bool isAtmCalibrated, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), Real maxErrorTolerance=Null< Real >(), ext::shared_ptr< OptimizationMethod > const & optMethod=ext::shared_ptr< OptimizationMethod >(), Real const errorAccept=Null< Real >(), bool const useMaxError=False, Size const maxGuesses=50, bool const backwardFlat=False, Real const cutoffStrike=0.0001)"},
	 { "SabrSwaptionVolatilityCube_sparseSabrParameters", _wrap_SabrSwaptionVolatilityCube_sparseSabrParameters, METH_O, "SabrSwaptionVolatilityCube_sparseSabrParameters(SabrSwaptionVolatilityCube self) -> Matrix"},
	 { "SabrSwaptionVolatilityCube_denseSabrParameters", _wrap_SabrSwaptionVolatilityCube_denseSabrParameters, METH_O, "SabrSwaptionVolatilityCube_denseSabrParameters(SabrSwaptionVolatilityCube self) -> Matrix"},
	 { "SabrSwaptionVolatilityCube_marketVolCube", _wrap_SabrSwaptionVolatilityCube_marketVolCube, METH_O, "SabrSwaptionVolatilityCube_marketVolCube(SabrSwaptionVolatilityCube self) -> Matrix"},
	 { "SabrSwaptionVolatilityCube_volCubeAtmCalibrated", _wrap_SabrSwaptionVolatilityCube_volCubeAtmCalibrated, METH_O, "SabrSwaptionVolatilityCube_volCubeAtmCalibrated(SabrSwaptionVolatilityCube self) -> Matrix"},
	 { "SabrSwaptionVolatilityCube_smileSection", _wrap_SabrSwaptionVolatilityCube_smileSection, METH_VARARGS, "\n"
		"SabrSwaptionVolatilityCube_smileSection(SabrSwaptionVolatilityCube self, Time optionTime, Time swapLength, bool extr=False) -> ext::shared_ptr< SabrSmileSection >\n"
		"SabrSwaptionVolatilityCube_smileSection(SabrSwaptionVolatilityCube self, Period optionTenor, Period swapTenor, bool extr=False) -> ext::shared_ptr< SabrSmileSection >\n"
		""},
	 { "delete_SabrSwaptionVolatilityCube", _wrap_delete_SabrSwaptionVolatilityCube, METH_O, "delete_SabrSwaptionVolatilityCube(SabrSwaptionVolatilityCube self)"},
	 { "SabrSwaptionVolatilityCube_swigregister", SabrSwaptionVolatilityCube_swigregister, METH_O, NULL},
	 { "SabrSwaptionVolatilityCube_swiginit", SabrSwaptionVolatilityCube_swiginit, METH_VARARGS, NULL},
	 { "new_InterpolatedSwaptionVolatilityCube", _wrap_new_InterpolatedSwaptionVolatilityCube, METH_VARARGS, "new_InterpolatedSwaptionVolatilityCube(SwaptionVolatilityStructureHandle atmVolStructure, PeriodVector optionTenors, PeriodVector swapTenors, DoubleVector strikeSpreads, QuoteHandleVectorVector volSpreads, ext::shared_ptr< SwapIndex > const & swapIndex, ext::shared_ptr< SwapIndex > const & shortSwapIndex, bool vegaWeightedSmileFit) -> InterpolatedSwaptionVolatilityCube"},
	 { "delete_InterpolatedSwaptionVolatilityCube", _wrap_delete_InterpolatedSwaptionVolatilityCube, METH_O, "delete_InterpolatedSwaptionVolatilityCube(InterpolatedSwaptionVolatilityCube self)"},
	 { "InterpolatedSwaptionVolatilityCube_swigregister", InterpolatedSwaptionVolatilityCube_swigregister, METH_O, NULL},
	 { "InterpolatedSwaptionVolatilityCube_swiginit", InterpolatedSwaptionVolatilityCube_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantYoYOptionletVolatility", _wrap_new_ConstantYoYOptionletVolatility, METH_VARARGS, "ConstantYoYOptionletVolatility(Volatility volatility, Natural settlementDays, Calendar cal, BusinessDayConvention bdc, DayCounter dc, Period observationLag, Frequency frequency, bool indexIsInterpolated, Real minStrike=-1.0, Real maxStrike=100.0)"},
	 { "delete_ConstantYoYOptionletVolatility", _wrap_delete_ConstantYoYOptionletVolatility, METH_O, "delete_ConstantYoYOptionletVolatility(ConstantYoYOptionletVolatility self)"},
	 { "ConstantYoYOptionletVolatility_swigregister", ConstantYoYOptionletVolatility_swigregister, METH_O, NULL},
	 { "ConstantYoYOptionletVolatility_swiginit", ConstantYoYOptionletVolatility_swiginit, METH_VARARGS, NULL},
	 { "new_FlatSmileSection", _wrap_new_FlatSmileSection, METH_VARARGS, "\n"
		"FlatSmileSection(Date d, Volatility vol, DayCounter dc, Date referenceDate=Date(), Real atmLevel=Null< Rate >(), VolatilityType type=ShiftedLognormal, Real shift=0.0)\n"
		"FlatSmileSection(Time exerciseTime, Volatility vol, DayCounter dc, Real atmLevel=Null< Rate >(), VolatilityType type=ShiftedLognormal, Real shift=0.0)\n"
		""},
	 { "delete_FlatSmileSection", _wrap_delete_FlatSmileSection, METH_O, "delete_FlatSmileSection(FlatSmileSection self)"},
	 { "FlatSmileSection_swigregister", FlatSmileSection_swigregister, METH_O, NULL},
	 { "FlatSmileSection_swiginit", FlatSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_LinearInterpolatedSmileSection", _wrap_new_LinearInterpolatedSmileSection, METH_VARARGS, "\n"
		"LinearInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, Linear interpolator=Linear(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"LinearInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, Linear interpolator=Linear(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"LinearInterpolatedSmileSection(Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), Linear interpolator=Linear(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"LinearInterpolatedSmileSection(Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), Linear interpolator=Linear(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "delete_LinearInterpolatedSmileSection", _wrap_delete_LinearInterpolatedSmileSection, METH_O, "delete_LinearInterpolatedSmileSection(LinearInterpolatedSmileSection self)"},
	 { "LinearInterpolatedSmileSection_swigregister", LinearInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "LinearInterpolatedSmileSection_swiginit", LinearInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_CubicInterpolatedSmileSection", _wrap_new_CubicInterpolatedSmileSection, METH_VARARGS, "\n"
		"CubicInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, Cubic interpolator=Cubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"CubicInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, Cubic interpolator=Cubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"CubicInterpolatedSmileSection(Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), Cubic interpolator=Cubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"CubicInterpolatedSmileSection(Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), Cubic interpolator=Cubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "delete_CubicInterpolatedSmileSection", _wrap_delete_CubicInterpolatedSmileSection, METH_O, "delete_CubicInterpolatedSmileSection(CubicInterpolatedSmileSection self)"},
	 { "CubicInterpolatedSmileSection_swigregister", CubicInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "CubicInterpolatedSmileSection_swiginit", CubicInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubicInterpolatedSmileSection", _wrap_new_MonotonicCubicInterpolatedSmileSection, METH_VARARGS, "\n"
		"MonotonicCubicInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, MonotonicCubic interpolator=MonotonicCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"MonotonicCubicInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, MonotonicCubic interpolator=MonotonicCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"MonotonicCubicInterpolatedSmileSection(Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), MonotonicCubic interpolator=MonotonicCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"MonotonicCubicInterpolatedSmileSection(Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), MonotonicCubic interpolator=MonotonicCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "delete_MonotonicCubicInterpolatedSmileSection", _wrap_delete_MonotonicCubicInterpolatedSmileSection, METH_O, "delete_MonotonicCubicInterpolatedSmileSection(MonotonicCubicInterpolatedSmileSection self)"},
	 { "MonotonicCubicInterpolatedSmileSection_swigregister", MonotonicCubicInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "MonotonicCubicInterpolatedSmileSection_swiginit", MonotonicCubicInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_SplineCubicInterpolatedSmileSection", _wrap_new_SplineCubicInterpolatedSmileSection, METH_VARARGS, "\n"
		"SplineCubicInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, SplineCubic interpolator=SplineCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"SplineCubicInterpolatedSmileSection(Time expiryTime, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, SplineCubic interpolator=SplineCubic(), DayCounter dc=Actual365Fixed(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"SplineCubicInterpolatedSmileSection(Date d, DoubleVector strikes, QuoteHandleVector stdDevHandles, QuoteHandle atmLevel, DayCounter dc=Actual365Fixed(), SplineCubic interpolator=SplineCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"SplineCubicInterpolatedSmileSection(Date d, DoubleVector strikes, DoubleVector stdDevs, Real atmLevel, DayCounter dc=Actual365Fixed(), SplineCubic interpolator=SplineCubic(), Date referenceDate=Date(), VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "delete_SplineCubicInterpolatedSmileSection", _wrap_delete_SplineCubicInterpolatedSmileSection, METH_O, "delete_SplineCubicInterpolatedSmileSection(SplineCubicInterpolatedSmileSection self)"},
	 { "SplineCubicInterpolatedSmileSection_swigregister", SplineCubicInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "SplineCubicInterpolatedSmileSection_swiginit", SplineCubicInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_KahaleSmileSection", _wrap_new_KahaleSmileSection, METH_VARARGS, "KahaleSmileSection(ext::shared_ptr< SmileSection > const source, Real const atm=Null< Real >(), bool const interpolate=False, bool const exponentialExtrapolation=False, bool const deleteArbitragePoints=False, DoubleVector moneynessGrid=std::vector< Real >(), Real const gap=1.0E-5, int const forcedLeftIndex=-1, int const forcedRightIndex=QL_MAX_INTEGER)"},
	 { "delete_KahaleSmileSection", _wrap_delete_KahaleSmileSection, METH_O, "delete_KahaleSmileSection(KahaleSmileSection self)"},
	 { "KahaleSmileSection_swigregister", KahaleSmileSection_swigregister, METH_O, NULL},
	 { "KahaleSmileSection_swiginit", KahaleSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityLognormal", _wrap_new_ZabrShortMaturityLognormal, METH_NOARGS, "new_ZabrShortMaturityLognormal() -> ZabrShortMaturityLognormal"},
	 { "delete_ZabrShortMaturityLognormal", _wrap_delete_ZabrShortMaturityLognormal, METH_O, "delete_ZabrShortMaturityLognormal(ZabrShortMaturityLognormal self)"},
	 { "ZabrShortMaturityLognormal_swigregister", ZabrShortMaturityLognormal_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityLognormal_swiginit", ZabrShortMaturityLognormal_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityNormal", _wrap_new_ZabrShortMaturityNormal, METH_NOARGS, "new_ZabrShortMaturityNormal() -> ZabrShortMaturityNormal"},
	 { "delete_ZabrShortMaturityNormal", _wrap_delete_ZabrShortMaturityNormal, METH_O, "delete_ZabrShortMaturityNormal(ZabrShortMaturityNormal self)"},
	 { "ZabrShortMaturityNormal_swigregister", ZabrShortMaturityNormal_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityNormal_swiginit", ZabrShortMaturityNormal_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrLocalVolatility", _wrap_new_ZabrLocalVolatility, METH_NOARGS, "new_ZabrLocalVolatility() -> ZabrLocalVolatility"},
	 { "delete_ZabrLocalVolatility", _wrap_delete_ZabrLocalVolatility, METH_O, "delete_ZabrLocalVolatility(ZabrLocalVolatility self)"},
	 { "ZabrLocalVolatility_swigregister", ZabrLocalVolatility_swigregister, METH_O, NULL},
	 { "ZabrLocalVolatility_swiginit", ZabrLocalVolatility_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrFullFd", _wrap_new_ZabrFullFd, METH_NOARGS, "new_ZabrFullFd() -> ZabrFullFd"},
	 { "delete_ZabrFullFd", _wrap_delete_ZabrFullFd, METH_O, "delete_ZabrFullFd(ZabrFullFd self)"},
	 { "ZabrFullFd_swigregister", ZabrFullFd_swigregister, METH_O, NULL},
	 { "ZabrFullFd_swiginit", ZabrFullFd_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityLognormalSmileSection", _wrap_new_ZabrShortMaturityLognormalSmileSection, METH_VARARGS, "\n"
		"ZabrShortMaturityLognormalSmileSection(Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		"ZabrShortMaturityLognormalSmileSection(Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		""},
	 { "delete_ZabrShortMaturityLognormalSmileSection", _wrap_delete_ZabrShortMaturityLognormalSmileSection, METH_O, "delete_ZabrShortMaturityLognormalSmileSection(ZabrShortMaturityLognormalSmileSection self)"},
	 { "ZabrShortMaturityLognormalSmileSection_swigregister", ZabrShortMaturityLognormalSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityLognormalSmileSection_swiginit", ZabrShortMaturityLognormalSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityNormalSmileSection", _wrap_new_ZabrShortMaturityNormalSmileSection, METH_VARARGS, "\n"
		"ZabrShortMaturityNormalSmileSection(Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		"ZabrShortMaturityNormalSmileSection(Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		""},
	 { "delete_ZabrShortMaturityNormalSmileSection", _wrap_delete_ZabrShortMaturityNormalSmileSection, METH_O, "delete_ZabrShortMaturityNormalSmileSection(ZabrShortMaturityNormalSmileSection self)"},
	 { "ZabrShortMaturityNormalSmileSection_swigregister", ZabrShortMaturityNormalSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityNormalSmileSection_swiginit", ZabrShortMaturityNormalSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrLocalVolatilitySmileSection", _wrap_new_ZabrLocalVolatilitySmileSection, METH_VARARGS, "\n"
		"ZabrLocalVolatilitySmileSection(Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		"ZabrLocalVolatilitySmileSection(Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		""},
	 { "delete_ZabrLocalVolatilitySmileSection", _wrap_delete_ZabrLocalVolatilitySmileSection, METH_O, "delete_ZabrLocalVolatilitySmileSection(ZabrLocalVolatilitySmileSection self)"},
	 { "ZabrLocalVolatilitySmileSection_swigregister", ZabrLocalVolatilitySmileSection_swigregister, METH_O, NULL},
	 { "ZabrLocalVolatilitySmileSection_swiginit", ZabrLocalVolatilitySmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrFullFdSmileSection", _wrap_new_ZabrFullFdSmileSection, METH_VARARGS, "\n"
		"ZabrFullFdSmileSection(Time timeToExpiry, Rate forward, DoubleVector zabrParameters, DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		"ZabrFullFdSmileSection(Date d, Rate forward, DoubleVector zabrParameters, DayCounter dc=Actual365Fixed(), DoubleVector moneyness=std::vector< Real >(), Size const fdRefinement=5)\n"
		""},
	 { "delete_ZabrFullFdSmileSection", _wrap_delete_ZabrFullFdSmileSection, METH_O, "delete_ZabrFullFdSmileSection(ZabrFullFdSmileSection self)"},
	 { "ZabrFullFdSmileSection_swigregister", ZabrFullFdSmileSection_swigregister, METH_O, NULL},
	 { "ZabrFullFdSmileSection_swiginit", ZabrFullFdSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityLognormalInterpolatedSmileSection", _wrap_new_ZabrShortMaturityLognormalInterpolatedSmileSection, METH_VARARGS, "\n"
		"ZabrShortMaturityLognormalInterpolatedSmileSection(Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		"ZabrShortMaturityLognormalInterpolatedSmileSection(Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		""},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_alpha", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_alpha, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_alpha(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_beta", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_beta, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_beta(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_nu", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_nu, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_nu(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_rho", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_rho, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_rho(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_rmsError(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_maxError", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_maxError, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_maxError(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria", _wrap_ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria, METH_O, "ZabrShortMaturityLognormalInterpolatedSmileSection_endCriteria(ZabrShortMaturityLognormalInterpolatedSmileSection self) -> EndCriteria::Type"},
	 { "delete_ZabrShortMaturityLognormalInterpolatedSmileSection", _wrap_delete_ZabrShortMaturityLognormalInterpolatedSmileSection, METH_O, "delete_ZabrShortMaturityLognormalInterpolatedSmileSection(ZabrShortMaturityLognormalInterpolatedSmileSection self)"},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister", ZabrShortMaturityLognormalInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit", ZabrShortMaturityLognormalInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrShortMaturityNormalInterpolatedSmileSection", _wrap_new_ZabrShortMaturityNormalInterpolatedSmileSection, METH_VARARGS, "\n"
		"ZabrShortMaturityNormalInterpolatedSmileSection(Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		"ZabrShortMaturityNormalInterpolatedSmileSection(Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		""},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_alpha", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_alpha, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_alpha(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_beta", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_beta, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_beta(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_nu", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_nu, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_nu(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_rho", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_rho, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_rho(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_rmsError", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_rmsError, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_rmsError(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_maxError", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_maxError, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_maxError(ZabrShortMaturityNormalInterpolatedSmileSection self) -> Real"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria", _wrap_ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria, METH_O, "ZabrShortMaturityNormalInterpolatedSmileSection_endCriteria(ZabrShortMaturityNormalInterpolatedSmileSection self) -> EndCriteria::Type"},
	 { "delete_ZabrShortMaturityNormalInterpolatedSmileSection", _wrap_delete_ZabrShortMaturityNormalInterpolatedSmileSection, METH_O, "delete_ZabrShortMaturityNormalInterpolatedSmileSection(ZabrShortMaturityNormalInterpolatedSmileSection self)"},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_swigregister", ZabrShortMaturityNormalInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrShortMaturityNormalInterpolatedSmileSection_swiginit", ZabrShortMaturityNormalInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrLocalVolatilityInterpolatedSmileSection", _wrap_new_ZabrLocalVolatilityInterpolatedSmileSection, METH_VARARGS, "\n"
		"ZabrLocalVolatilityInterpolatedSmileSection(Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		"ZabrLocalVolatilityInterpolatedSmileSection(Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		""},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_alpha", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_alpha, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_alpha(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_beta", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_beta, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_beta(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_nu", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_nu, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_nu(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_rho", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_rho, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_rho(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_rmsError", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_rmsError, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_rmsError(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_maxError", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_maxError, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_maxError(ZabrLocalVolatilityInterpolatedSmileSection self) -> Real"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_endCriteria", _wrap_ZabrLocalVolatilityInterpolatedSmileSection_endCriteria, METH_O, "ZabrLocalVolatilityInterpolatedSmileSection_endCriteria(ZabrLocalVolatilityInterpolatedSmileSection self) -> EndCriteria::Type"},
	 { "delete_ZabrLocalVolatilityInterpolatedSmileSection", _wrap_delete_ZabrLocalVolatilityInterpolatedSmileSection, METH_O, "delete_ZabrLocalVolatilityInterpolatedSmileSection(ZabrLocalVolatilityInterpolatedSmileSection self)"},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_swigregister", ZabrLocalVolatilityInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrLocalVolatilityInterpolatedSmileSection_swiginit", ZabrLocalVolatilityInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_ZabrFullFdInterpolatedSmileSection", _wrap_new_ZabrFullFdInterpolatedSmileSection, METH_VARARGS, "\n"
		"ZabrFullFdInterpolatedSmileSection(Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		"ZabrFullFdInterpolatedSmileSection(Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, Real gamma, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool isGammaFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		""},
	 { "ZabrFullFdInterpolatedSmileSection_alpha", _wrap_ZabrFullFdInterpolatedSmileSection_alpha, METH_O, "ZabrFullFdInterpolatedSmileSection_alpha(ZabrFullFdInterpolatedSmileSection self) -> Real"},
	 { "ZabrFullFdInterpolatedSmileSection_beta", _wrap_ZabrFullFdInterpolatedSmileSection_beta, METH_O, "ZabrFullFdInterpolatedSmileSection_beta(ZabrFullFdInterpolatedSmileSection self) -> Real"},
	 { "ZabrFullFdInterpolatedSmileSection_nu", _wrap_ZabrFullFdInterpolatedSmileSection_nu, METH_O, "ZabrFullFdInterpolatedSmileSection_nu(ZabrFullFdInterpolatedSmileSection self) -> Real"},
	 { "ZabrFullFdInterpolatedSmileSection_rho", _wrap_ZabrFullFdInterpolatedSmileSection_rho, METH_O, "ZabrFullFdInterpolatedSmileSection_rho(ZabrFullFdInterpolatedSmileSection self) -> Real"},
	 { "ZabrFullFdInterpolatedSmileSection_rmsError", _wrap_ZabrFullFdInterpolatedSmileSection_rmsError, METH_O, "ZabrFullFdInterpolatedSmileSection_rmsError(ZabrFullFdInterpolatedSmileSection self) -> Real"},
	 { "ZabrFullFdInterpolatedSmileSection_maxError", _wrap_ZabrFullFdInterpolatedSmileSection_maxError, METH_O, "ZabrFullFdInterpolatedSmileSection_maxError(ZabrFullFdInterpolatedSmileSection self) -> Real"},
	 { "ZabrFullFdInterpolatedSmileSection_endCriteria", _wrap_ZabrFullFdInterpolatedSmileSection_endCriteria, METH_O, "ZabrFullFdInterpolatedSmileSection_endCriteria(ZabrFullFdInterpolatedSmileSection self) -> EndCriteria::Type"},
	 { "delete_ZabrFullFdInterpolatedSmileSection", _wrap_delete_ZabrFullFdInterpolatedSmileSection, METH_O, "delete_ZabrFullFdInterpolatedSmileSection(ZabrFullFdInterpolatedSmileSection self)"},
	 { "ZabrFullFdInterpolatedSmileSection_swigregister", ZabrFullFdInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "ZabrFullFdInterpolatedSmileSection_swiginit", ZabrFullFdInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_NoArbSabrSmileSection", _wrap_new_NoArbSabrSmileSection, METH_VARARGS, "\n"
		"NoArbSabrSmileSection(Time timeToExpiry, Rate forward, DoubleVector sabrParameters, Real const shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal)\n"
		"NoArbSabrSmileSection(Date d, Rate forward, DoubleVector sabrParameters, DayCounter dc=Actual365Fixed(), Real const shift=0.0, VolatilityType volatilityType=VolatilityType::ShiftedLognormal)\n"
		""},
	 { "delete_NoArbSabrSmileSection", _wrap_delete_NoArbSabrSmileSection, METH_O, "delete_NoArbSabrSmileSection(NoArbSabrSmileSection self)"},
	 { "NoArbSabrSmileSection_swigregister", NoArbSabrSmileSection_swigregister, METH_O, NULL},
	 { "NoArbSabrSmileSection_swiginit", NoArbSabrSmileSection_swiginit, METH_VARARGS, NULL},
	 { "new_NoArbSabrInterpolatedSmileSection", _wrap_new_NoArbSabrInterpolatedSmileSection, METH_VARARGS, "\n"
		"NoArbSabrInterpolatedSmileSection(Date optionDate, QuoteHandle forward, DoubleVector strikes, bool hasFloatingStrikes, QuoteHandle atmVolatility, QuoteHandleVector volHandles, Real alpha, Real beta, Real nu, Real rho, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		"NoArbSabrInterpolatedSmileSection(Date optionDate, Rate const & forward, DoubleVector strikes, bool hasFloatingStrikes, Volatility const & atmVolatility, DoubleVector vols, Real alpha, Real beta, Real nu, Real rho, bool isAlphaFixed=False, bool isBetaFixed=False, bool isNuFixed=False, bool isRhoFixed=False, bool vegaWeighted=True, ext::shared_ptr< EndCriteria > const & endCriteria=ext::shared_ptr< EndCriteria >(), ext::shared_ptr< OptimizationMethod > const & method=ext::shared_ptr< OptimizationMethod >(), DayCounter dc=Actual365Fixed())\n"
		""},
	 { "NoArbSabrInterpolatedSmileSection_alpha", _wrap_NoArbSabrInterpolatedSmileSection_alpha, METH_O, "NoArbSabrInterpolatedSmileSection_alpha(NoArbSabrInterpolatedSmileSection self) -> Real"},
	 { "NoArbSabrInterpolatedSmileSection_beta", _wrap_NoArbSabrInterpolatedSmileSection_beta, METH_O, "NoArbSabrInterpolatedSmileSection_beta(NoArbSabrInterpolatedSmileSection self) -> Real"},
	 { "NoArbSabrInterpolatedSmileSection_nu", _wrap_NoArbSabrInterpolatedSmileSection_nu, METH_O, "NoArbSabrInterpolatedSmileSection_nu(NoArbSabrInterpolatedSmileSection self) -> Real"},
	 { "NoArbSabrInterpolatedSmileSection_rho", _wrap_NoArbSabrInterpolatedSmileSection_rho, METH_O, "NoArbSabrInterpolatedSmileSection_rho(NoArbSabrInterpolatedSmileSection self) -> Real"},
	 { "NoArbSabrInterpolatedSmileSection_rmsError", _wrap_NoArbSabrInterpolatedSmileSection_rmsError, METH_O, "NoArbSabrInterpolatedSmileSection_rmsError(NoArbSabrInterpolatedSmileSection self) -> Real"},
	 { "NoArbSabrInterpolatedSmileSection_maxError", _wrap_NoArbSabrInterpolatedSmileSection_maxError, METH_O, "NoArbSabrInterpolatedSmileSection_maxError(NoArbSabrInterpolatedSmileSection self) -> Real"},
	 { "NoArbSabrInterpolatedSmileSection_endCriteria", _wrap_NoArbSabrInterpolatedSmileSection_endCriteria, METH_O, "NoArbSabrInterpolatedSmileSection_endCriteria(NoArbSabrInterpolatedSmileSection self) -> EndCriteria::Type"},
	 { "delete_NoArbSabrInterpolatedSmileSection", _wrap_delete_NoArbSabrInterpolatedSmileSection, METH_O, "delete_NoArbSabrInterpolatedSmileSection(NoArbSabrInterpolatedSmileSection self)"},
	 { "NoArbSabrInterpolatedSmileSection_swigregister", NoArbSabrInterpolatedSmileSection_swigregister, METH_O, NULL},
	 { "NoArbSabrInterpolatedSmileSection_swiginit", NoArbSabrInterpolatedSmileSection_swiginit, METH_VARARGS, NULL},
	 { "sabrVolatility", _wrap_sabrVolatility, METH_VARARGS, "sabrVolatility(Rate strike, Rate forward, Time expiryTime, Real alpha, Real beta, Real nu, Real rho, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> Real"},
	 { "shiftedSabrVolatility", _wrap_shiftedSabrVolatility, METH_VARARGS, "shiftedSabrVolatility(Rate strike, Rate forward, Time expiryTime, Real alpha, Real beta, Real nu, Real rho, Real shift, VolatilityType volatilityType=VolatilityType::ShiftedLognormal) -> Real"},
	 { "sabrFlochKennedyVolatility", _wrap_sabrFlochKennedyVolatility, METH_VARARGS, "sabrFlochKennedyVolatility(Rate strike, Rate forward, Time expiryTime, Real alpha, Real beta, Real nu, Real rho) -> Real"},
	 { "new_CalibrationErrorTuple", _wrap_new_CalibrationErrorTuple, METH_VARARGS, "new_CalibrationErrorTuple(double arg1, double arg2, double arg3) -> CalibrationErrorTuple"},
	 { "CalibrationErrorTuple_first", _wrap_CalibrationErrorTuple_first, METH_O, "CalibrationErrorTuple_first(CalibrationErrorTuple self) -> double"},
	 { "CalibrationErrorTuple_second", _wrap_CalibrationErrorTuple_second, METH_O, "CalibrationErrorTuple_second(CalibrationErrorTuple self) -> double"},
	 { "CalibrationErrorTuple_third", _wrap_CalibrationErrorTuple_third, METH_O, "CalibrationErrorTuple_third(CalibrationErrorTuple self) -> double"},
	 { "delete_CalibrationErrorTuple", _wrap_delete_CalibrationErrorTuple, METH_O, "delete_CalibrationErrorTuple(CalibrationErrorTuple self)"},
	 { "CalibrationErrorTuple_swigregister", CalibrationErrorTuple_swigregister, METH_O, NULL},
	 { "CalibrationErrorTuple_swiginit", CalibrationErrorTuple_swiginit, METH_VARARGS, NULL},
	 { "new_AndreasenHugeVolatilityInterpl", _wrap_new_AndreasenHugeVolatilityInterpl, METH_VARARGS, "AndreasenHugeVolatilityInterpl(CalibrationSet calibrationSet, QuoteHandle spot, YieldTermStructureHandle rTS, YieldTermStructureHandle qTS, AndreasenHugeVolatilityInterpl::InterpolationType interpolationType=CubicSpline, AndreasenHugeVolatilityInterpl::CalibrationType calibrationType=Call, Size nGridPoints=500, Real minStrike=Null< Real >(), Real maxStrike=Null< Real >(), ext::shared_ptr< OptimizationMethod > const & optimizationMethod=ext::shared_ptr< OptimizationMethod >(new LevenbergMarquardt), EndCriteria endCriteria=EndCriteria(500, 100, 1e-12, 1e-10, 1e-10))"},
	 { "AndreasenHugeVolatilityInterpl_maxDate", _wrap_AndreasenHugeVolatilityInterpl_maxDate, METH_O, "AndreasenHugeVolatilityInterpl_maxDate(AndreasenHugeVolatilityInterpl self) -> Date"},
	 { "AndreasenHugeVolatilityInterpl_minStrike", _wrap_AndreasenHugeVolatilityInterpl_minStrike, METH_O, "AndreasenHugeVolatilityInterpl_minStrike(AndreasenHugeVolatilityInterpl self) -> Real"},
	 { "AndreasenHugeVolatilityInterpl_maxStrike", _wrap_AndreasenHugeVolatilityInterpl_maxStrike, METH_O, "AndreasenHugeVolatilityInterpl_maxStrike(AndreasenHugeVolatilityInterpl self) -> Real"},
	 { "AndreasenHugeVolatilityInterpl_fwd", _wrap_AndreasenHugeVolatilityInterpl_fwd, METH_VARARGS, "AndreasenHugeVolatilityInterpl_fwd(AndreasenHugeVolatilityInterpl self, Time t) -> Real"},
	 { "AndreasenHugeVolatilityInterpl_riskFreeRate", _wrap_AndreasenHugeVolatilityInterpl_riskFreeRate, METH_O, "AndreasenHugeVolatilityInterpl_riskFreeRate(AndreasenHugeVolatilityInterpl self) -> YieldTermStructureHandle"},
	 { "AndreasenHugeVolatilityInterpl_calibrationError", _wrap_AndreasenHugeVolatilityInterpl_calibrationError, METH_O, "AndreasenHugeVolatilityInterpl_calibrationError(AndreasenHugeVolatilityInterpl self) -> CalibrationErrorTuple"},
	 { "AndreasenHugeVolatilityInterpl_optionPrice", _wrap_AndreasenHugeVolatilityInterpl_optionPrice, METH_VARARGS, "AndreasenHugeVolatilityInterpl_optionPrice(AndreasenHugeVolatilityInterpl self, Time t, Real strike, Option::Type optionType) -> Real"},
	 { "AndreasenHugeVolatilityInterpl_localVol", _wrap_AndreasenHugeVolatilityInterpl_localVol, METH_VARARGS, "AndreasenHugeVolatilityInterpl_localVol(AndreasenHugeVolatilityInterpl self, Time t, Real strike) -> Volatility"},
	 { "delete_AndreasenHugeVolatilityInterpl", _wrap_delete_AndreasenHugeVolatilityInterpl, METH_O, "delete_AndreasenHugeVolatilityInterpl(AndreasenHugeVolatilityInterpl self)"},
	 { "AndreasenHugeVolatilityInterpl_swigregister", AndreasenHugeVolatilityInterpl_swigregister, METH_O, NULL},
	 { "AndreasenHugeVolatilityInterpl_swiginit", AndreasenHugeVolatilityInterpl_swiginit, METH_VARARGS, NULL},
	 { "new_AndreasenHugeVolatilityAdapter", _wrap_new_AndreasenHugeVolatilityAdapter, METH_VARARGS, "AndreasenHugeVolatilityAdapter(ext::shared_ptr< AndreasenHugeVolatilityInterpl > const & volInterpl, Real eps=1e-6)"},
	 { "delete_AndreasenHugeVolatilityAdapter", _wrap_delete_AndreasenHugeVolatilityAdapter, METH_O, "delete_AndreasenHugeVolatilityAdapter(AndreasenHugeVolatilityAdapter self)"},
	 { "AndreasenHugeVolatilityAdapter_swigregister", AndreasenHugeVolatilityAdapter_swigregister, METH_O, NULL},
	 { "AndreasenHugeVolatilityAdapter_swiginit", AndreasenHugeVolatilityAdapter_swiginit, METH_VARARGS, NULL},
	 { "new_AndreasenHugeLocalVolAdapter", _wrap_new_AndreasenHugeLocalVolAdapter, METH_O, "new_AndreasenHugeLocalVolAdapter(ext::shared_ptr< AndreasenHugeVolatilityInterpl > const & localVol) -> AndreasenHugeLocalVolAdapter"},
	 { "delete_AndreasenHugeLocalVolAdapter", _wrap_delete_AndreasenHugeLocalVolAdapter, METH_O, "delete_AndreasenHugeLocalVolAdapter(AndreasenHugeLocalVolAdapter self)"},
	 { "AndreasenHugeLocalVolAdapter_swigregister", AndreasenHugeLocalVolAdapter_swigregister, METH_O, NULL},
	 { "AndreasenHugeLocalVolAdapter_swiginit", AndreasenHugeLocalVolAdapter_swiginit, METH_VARARGS, NULL},
	 { "new_HestonBlackVolSurface", _wrap_new_HestonBlackVolSurface, METH_VARARGS, "HestonBlackVolSurface(HestonModelHandle hestonModel, AnalyticHestonEngine::ComplexLogFormula const cpxLogFormula=Gatheral, AnalyticHestonEngine_Integration integration=AnalyticHestonEngine::Integration::gaussLaguerre(164))"},
	 { "delete_HestonBlackVolSurface", _wrap_delete_HestonBlackVolSurface, METH_O, "delete_HestonBlackVolSurface(HestonBlackVolSurface self)"},
	 { "HestonBlackVolSurface_swigregister", HestonBlackVolSurface_swigregister, METH_O, NULL},
	 { "HestonBlackVolSurface_swiginit", HestonBlackVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_CmsMarket", _wrap_new_CmsMarket, METH_VARARGS, "new_CmsMarket(PeriodVector swapLengths, SwapIndexVector swapIndexes, ext::shared_ptr< IborIndex > const & iborIndex, QuoteHandleVectorVector bidAskSpreads, CmsCouponPricerVector pricers, YieldTermStructureHandle discountingTS) -> CmsMarket"},
	 { "CmsMarket_reprice", _wrap_CmsMarket_reprice, METH_VARARGS, "CmsMarket_reprice(CmsMarket self, SwaptionVolatilityStructureHandle volStructure, Real meanReversion)"},
	 { "CmsMarket_swapTenors", _wrap_CmsMarket_swapTenors, METH_O, "CmsMarket_swapTenors(CmsMarket self) -> PeriodVector"},
	 { "CmsMarket_swapLengths", _wrap_CmsMarket_swapLengths, METH_O, "CmsMarket_swapLengths(CmsMarket self) -> PeriodVector"},
	 { "CmsMarket_impliedCmsSpreads", _wrap_CmsMarket_impliedCmsSpreads, METH_O, "CmsMarket_impliedCmsSpreads(CmsMarket self) -> Matrix"},
	 { "CmsMarket_spreadErrors", _wrap_CmsMarket_spreadErrors, METH_O, "CmsMarket_spreadErrors(CmsMarket self) -> Matrix"},
	 { "CmsMarket_browse", _wrap_CmsMarket_browse, METH_O, "CmsMarket_browse(CmsMarket self) -> Matrix"},
	 { "CmsMarket_weightedSpreadError", _wrap_CmsMarket_weightedSpreadError, METH_VARARGS, "CmsMarket_weightedSpreadError(CmsMarket self, Matrix weights) -> Real"},
	 { "CmsMarket_weightedSpotNpvError", _wrap_CmsMarket_weightedSpotNpvError, METH_VARARGS, "CmsMarket_weightedSpotNpvError(CmsMarket self, Matrix weights) -> Real"},
	 { "CmsMarket_weightedFwdNpvError", _wrap_CmsMarket_weightedFwdNpvError, METH_VARARGS, "CmsMarket_weightedFwdNpvError(CmsMarket self, Matrix weights) -> Real"},
	 { "CmsMarket_weightedSpreadErrors", _wrap_CmsMarket_weightedSpreadErrors, METH_VARARGS, "CmsMarket_weightedSpreadErrors(CmsMarket self, Matrix weights) -> Array"},
	 { "CmsMarket_weightedSpotNpvErrors", _wrap_CmsMarket_weightedSpotNpvErrors, METH_VARARGS, "CmsMarket_weightedSpotNpvErrors(CmsMarket self, Matrix weights) -> Array"},
	 { "CmsMarket_weightedFwdNpvErrors", _wrap_CmsMarket_weightedFwdNpvErrors, METH_VARARGS, "CmsMarket_weightedFwdNpvErrors(CmsMarket self, Matrix weights) -> Array"},
	 { "delete_CmsMarket", _wrap_delete_CmsMarket, METH_O, "delete_CmsMarket(CmsMarket self)"},
	 { "CmsMarket_swigregister", CmsMarket_swigregister, METH_O, NULL},
	 { "CmsMarket_swiginit", CmsMarket_swiginit, METH_VARARGS, NULL},
	 { "new_CmsMarketCalibration", _wrap_new_CmsMarketCalibration, METH_VARARGS, "new_CmsMarketCalibration(SwaptionVolatilityStructureHandle volCube, ext::shared_ptr< CmsMarket > & cmsMarket, Matrix weights, CmsMarketCalibration::CalibrationType calibrationType) -> CmsMarketCalibration"},
	 { "CmsMarketCalibration_compute", _wrap_CmsMarketCalibration_compute, METH_VARARGS, "\n"
		"CmsMarketCalibration_compute(CmsMarketCalibration self, ext::shared_ptr< EndCriteria > const & endCriteria, ext::shared_ptr< OptimizationMethod > const & method, Array guess, bool isMeanReversionFixed) -> Array\n"
		"CmsMarketCalibration_compute(CmsMarketCalibration self, ext::shared_ptr< EndCriteria > const & endCriteria, ext::shared_ptr< OptimizationMethod > const & method, Matrix guess, bool isMeanReversionFixed, Real const meanReversionGuess=Null< Real >()) -> Matrix\n"
		""},
	 { "CmsMarketCalibration_computeParametric", _wrap_CmsMarketCalibration_computeParametric, METH_VARARGS, "CmsMarketCalibration_computeParametric(CmsMarketCalibration self, ext::shared_ptr< EndCriteria > const & endCriteria, ext::shared_ptr< OptimizationMethod > const & method, Matrix guess, bool isMeanReversionFixed, Real const meanReversionGuess=Null< Real >()) -> Matrix"},
	 { "CmsMarketCalibration_error", _wrap_CmsMarketCalibration_error, METH_O, "CmsMarketCalibration_error(CmsMarketCalibration self) -> Real"},
	 { "CmsMarketCalibration_endCriteria", _wrap_CmsMarketCalibration_endCriteria, METH_O, "CmsMarketCalibration_endCriteria(CmsMarketCalibration self) -> EndCriteria::Type"},
	 { "delete_CmsMarketCalibration", _wrap_delete_CmsMarketCalibration, METH_O, "delete_CmsMarketCalibration(CmsMarketCalibration self)"},
	 { "CmsMarketCalibration_swigregister", CmsMarketCalibration_swigregister, METH_O, NULL},
	 { "CmsMarketCalibration_swiginit", CmsMarketCalibration_swiginit, METH_VARARGS, NULL},
	 { "CashFlow_amount", _wrap_CashFlow_amount, METH_O, "CashFlow_amount(CashFlow self) -> Real"},
	 { "CashFlow_date", _wrap_CashFlow_date, METH_O, "CashFlow_date(CashFlow self) -> Date"},
	 { "CashFlow_hasOccurred", _wrap_CashFlow_hasOccurred, METH_VARARGS, "CashFlow_hasOccurred(CashFlow self, Date refDate=Date()) -> bool"},
	 { "delete_CashFlow", _wrap_delete_CashFlow, METH_O, "delete_CashFlow(CashFlow self)"},
	 { "CashFlow_swigregister", CashFlow_swigregister, METH_O, NULL},
	 { "Leg_iterator", _wrap_Leg_iterator, METH_O, "Leg_iterator(Leg self) -> SwigPyIterator"},
	 { "Leg___nonzero__", _wrap_Leg___nonzero__, METH_O, "Leg___nonzero__(Leg self) -> bool"},
	 { "Leg___bool__", _wrap_Leg___bool__, METH_O, "Leg___bool__(Leg self) -> bool"},
	 { "Leg___len__", _wrap_Leg___len__, METH_O, "Leg___len__(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::size_type"},
	 { "Leg___getslice__", _wrap_Leg___getslice__, METH_VARARGS, "Leg___getslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j) -> Leg"},
	 { "Leg___setslice__", _wrap_Leg___setslice__, METH_VARARGS, "\n"
		"Leg___setslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j)\n"
		"Leg___setslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j, Leg v)\n"
		""},
	 { "Leg___delslice__", _wrap_Leg___delslice__, METH_VARARGS, "Leg___delslice__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::difference_type j)"},
	 { "Leg___delitem__", _wrap_Leg___delitem__, METH_VARARGS, "\n"
		"Leg___delitem__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i)\n"
		"Leg___delitem__(Leg self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "Leg___getitem__", _wrap_Leg___getitem__, METH_VARARGS, "\n"
		"Leg___getitem__(Leg self, SWIGPY_SLICEOBJECT * slice) -> Leg\n"
		"Leg___getitem__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i) -> std::vector< ext::shared_ptr< CashFlow > >::value_type const &\n"
		""},
	 { "Leg___setitem__", _wrap_Leg___setitem__, METH_VARARGS, "\n"
		"Leg___setitem__(Leg self, SWIGPY_SLICEOBJECT * slice, Leg v)\n"
		"Leg___setitem__(Leg self, SWIGPY_SLICEOBJECT * slice)\n"
		"Leg___setitem__(Leg self, std::vector< ext::shared_ptr< CashFlow > >::difference_type i, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)\n"
		""},
	 { "Leg_pop", _wrap_Leg_pop, METH_O, "Leg_pop(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::value_type"},
	 { "Leg_append", _wrap_Leg_append, METH_VARARGS, "Leg_append(Leg self, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)"},
	 { "Leg_empty", _wrap_Leg_empty, METH_O, "Leg_empty(Leg self) -> bool"},
	 { "Leg_size", _wrap_Leg_size, METH_O, "Leg_size(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::size_type"},
	 { "Leg_swap", _wrap_Leg_swap, METH_VARARGS, "Leg_swap(Leg self, Leg v)"},
	 { "Leg_begin", _wrap_Leg_begin, METH_O, "Leg_begin(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::iterator"},
	 { "Leg_end", _wrap_Leg_end, METH_O, "Leg_end(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::iterator"},
	 { "Leg_rbegin", _wrap_Leg_rbegin, METH_O, "Leg_rbegin(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator"},
	 { "Leg_rend", _wrap_Leg_rend, METH_O, "Leg_rend(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::reverse_iterator"},
	 { "Leg_clear", _wrap_Leg_clear, METH_O, "Leg_clear(Leg self)"},
	 { "Leg_get_allocator", _wrap_Leg_get_allocator, METH_O, "Leg_get_allocator(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::allocator_type"},
	 { "Leg_pop_back", _wrap_Leg_pop_back, METH_O, "Leg_pop_back(Leg self)"},
	 { "Leg_erase", _wrap_Leg_erase, METH_VARARGS, "\n"
		"Leg_erase(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator pos) -> std::vector< ext::shared_ptr< CashFlow > >::iterator\n"
		"Leg_erase(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator first, std::vector< ext::shared_ptr< CashFlow > >::iterator last) -> std::vector< ext::shared_ptr< CashFlow > >::iterator\n"
		""},
	 { "new_Leg", _wrap_new_Leg, METH_VARARGS, "\n"
		"Leg()\n"
		"Leg(Leg other)\n"
		"Leg(std::vector< ext::shared_ptr< CashFlow > >::size_type size)\n"
		"new_Leg(std::vector< ext::shared_ptr< CashFlow > >::size_type size, std::vector< ext::shared_ptr< CashFlow > >::value_type const & value) -> Leg\n"
		""},
	 { "Leg_push_back", _wrap_Leg_push_back, METH_VARARGS, "Leg_push_back(Leg self, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)"},
	 { "Leg_front", _wrap_Leg_front, METH_O, "Leg_front(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::value_type const &"},
	 { "Leg_back", _wrap_Leg_back, METH_O, "Leg_back(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::value_type const &"},
	 { "Leg_assign", _wrap_Leg_assign, METH_VARARGS, "Leg_assign(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type n, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)"},
	 { "Leg_resize", _wrap_Leg_resize, METH_VARARGS, "\n"
		"Leg_resize(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type new_size)\n"
		"Leg_resize(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type new_size, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)\n"
		""},
	 { "Leg_insert", _wrap_Leg_insert, METH_VARARGS, "\n"
		"Leg_insert(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator pos, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x) -> std::vector< ext::shared_ptr< CashFlow > >::iterator\n"
		"Leg_insert(Leg self, std::vector< ext::shared_ptr< CashFlow > >::iterator pos, std::vector< ext::shared_ptr< CashFlow > >::size_type n, std::vector< ext::shared_ptr< CashFlow > >::value_type const & x)\n"
		""},
	 { "Leg_reserve", _wrap_Leg_reserve, METH_VARARGS, "Leg_reserve(Leg self, std::vector< ext::shared_ptr< CashFlow > >::size_type n)"},
	 { "Leg_capacity", _wrap_Leg_capacity, METH_O, "Leg_capacity(Leg self) -> std::vector< ext::shared_ptr< CashFlow > >::size_type"},
	 { "delete_Leg", _wrap_delete_Leg, METH_O, "delete_Leg(Leg self)"},
	 { "Leg_swigregister", Leg_swigregister, METH_O, NULL},
	 { "Leg_swiginit", Leg_swiginit, METH_VARARGS, NULL},
	 { "LegVector_iterator", _wrap_LegVector_iterator, METH_O, "LegVector_iterator(LegVector self) -> SwigPyIterator"},
	 { "LegVector___nonzero__", _wrap_LegVector___nonzero__, METH_O, "LegVector___nonzero__(LegVector self) -> bool"},
	 { "LegVector___bool__", _wrap_LegVector___bool__, METH_O, "LegVector___bool__(LegVector self) -> bool"},
	 { "LegVector___len__", _wrap_LegVector___len__, METH_O, "LegVector___len__(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type"},
	 { "LegVector___getslice__", _wrap_LegVector___getslice__, METH_VARARGS, "LegVector___getslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j) -> LegVector"},
	 { "LegVector___setslice__", _wrap_LegVector___setslice__, METH_VARARGS, "\n"
		"LegVector___setslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j)\n"
		"LegVector___setslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j, LegVector v)\n"
		""},
	 { "LegVector___delslice__", _wrap_LegVector___delslice__, METH_VARARGS, "LegVector___delslice__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type j)"},
	 { "LegVector___delitem__", _wrap_LegVector___delitem__, METH_VARARGS, "\n"
		"LegVector___delitem__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i)\n"
		"LegVector___delitem__(LegVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "LegVector___getitem__", _wrap_LegVector___getitem__, METH_VARARGS, "\n"
		"LegVector___getitem__(LegVector self, SWIGPY_SLICEOBJECT * slice) -> LegVector\n"
		"LegVector___getitem__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i) -> Leg\n"
		""},
	 { "LegVector___setitem__", _wrap_LegVector___setitem__, METH_VARARGS, "\n"
		"LegVector___setitem__(LegVector self, SWIGPY_SLICEOBJECT * slice, LegVector v)\n"
		"LegVector___setitem__(LegVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"LegVector___setitem__(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::difference_type i, Leg x)\n"
		""},
	 { "LegVector_pop", _wrap_LegVector_pop, METH_O, "LegVector_pop(LegVector self) -> Leg"},
	 { "LegVector_append", _wrap_LegVector_append, METH_VARARGS, "LegVector_append(LegVector self, Leg x)"},
	 { "LegVector_empty", _wrap_LegVector_empty, METH_O, "LegVector_empty(LegVector self) -> bool"},
	 { "LegVector_size", _wrap_LegVector_size, METH_O, "LegVector_size(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type"},
	 { "LegVector_swap", _wrap_LegVector_swap, METH_VARARGS, "LegVector_swap(LegVector self, LegVector v)"},
	 { "LegVector_begin", _wrap_LegVector_begin, METH_O, "LegVector_begin(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator"},
	 { "LegVector_end", _wrap_LegVector_end, METH_O, "LegVector_end(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator"},
	 { "LegVector_rbegin", _wrap_LegVector_rbegin, METH_O, "LegVector_rbegin(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator"},
	 { "LegVector_rend", _wrap_LegVector_rend, METH_O, "LegVector_rend(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::reverse_iterator"},
	 { "LegVector_clear", _wrap_LegVector_clear, METH_O, "LegVector_clear(LegVector self)"},
	 { "LegVector_get_allocator", _wrap_LegVector_get_allocator, METH_O, "LegVector_get_allocator(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::allocator_type"},
	 { "LegVector_pop_back", _wrap_LegVector_pop_back, METH_O, "LegVector_pop_back(LegVector self)"},
	 { "LegVector_erase", _wrap_LegVector_erase, METH_VARARGS, "\n"
		"LegVector_erase(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator\n"
		"LegVector_erase(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator first, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator last) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator\n"
		""},
	 { "new_LegVector", _wrap_new_LegVector, METH_VARARGS, "\n"
		"LegVector()\n"
		"LegVector(LegVector other)\n"
		"LegVector(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type size)\n"
		"new_LegVector(std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type size, Leg value) -> LegVector\n"
		""},
	 { "LegVector_push_back", _wrap_LegVector_push_back, METH_VARARGS, "LegVector_push_back(LegVector self, Leg x)"},
	 { "LegVector_front", _wrap_LegVector_front, METH_O, "LegVector_front(LegVector self) -> Leg"},
	 { "LegVector_back", _wrap_LegVector_back, METH_O, "LegVector_back(LegVector self) -> Leg"},
	 { "LegVector_assign", _wrap_LegVector_assign, METH_VARARGS, "LegVector_assign(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n, Leg x)"},
	 { "LegVector_resize", _wrap_LegVector_resize, METH_VARARGS, "\n"
		"LegVector_resize(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type new_size)\n"
		"LegVector_resize(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type new_size, Leg x)\n"
		""},
	 { "LegVector_insert", _wrap_LegVector_insert, METH_VARARGS, "\n"
		"LegVector_insert(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos, Leg x) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator\n"
		"LegVector_insert(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::iterator pos, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n, Leg x)\n"
		""},
	 { "LegVector_reserve", _wrap_LegVector_reserve, METH_VARARGS, "LegVector_reserve(LegVector self, std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type n)"},
	 { "LegVector_capacity", _wrap_LegVector_capacity, METH_O, "LegVector_capacity(LegVector self) -> std::vector< std::vector< ext::shared_ptr< CashFlow >,std::allocator< ext::shared_ptr< CashFlow > > > >::size_type"},
	 { "delete_LegVector", _wrap_delete_LegVector, METH_O, "delete_LegVector(LegVector self)"},
	 { "LegVector_swigregister", LegVector_swigregister, METH_O, NULL},
	 { "LegVector_swiginit", LegVector_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleCashFlow", _wrap_new_SimpleCashFlow, METH_VARARGS, "new_SimpleCashFlow(Real amount, Date date) -> SimpleCashFlow"},
	 { "delete_SimpleCashFlow", _wrap_delete_SimpleCashFlow, METH_O, "delete_SimpleCashFlow(SimpleCashFlow self)"},
	 { "SimpleCashFlow_swigregister", SimpleCashFlow_swigregister, METH_O, NULL},
	 { "SimpleCashFlow_swiginit", SimpleCashFlow_swiginit, METH_VARARGS, NULL},
	 { "new_Redemption", _wrap_new_Redemption, METH_VARARGS, "new_Redemption(Real amount, Date date) -> Redemption"},
	 { "delete_Redemption", _wrap_delete_Redemption, METH_O, "delete_Redemption(Redemption self)"},
	 { "Redemption_swigregister", Redemption_swigregister, METH_O, NULL},
	 { "Redemption_swiginit", Redemption_swiginit, METH_VARARGS, NULL},
	 { "new_AmortizingPayment", _wrap_new_AmortizingPayment, METH_VARARGS, "new_AmortizingPayment(Real amount, Date date) -> AmortizingPayment"},
	 { "delete_AmortizingPayment", _wrap_delete_AmortizingPayment, METH_O, "delete_AmortizingPayment(AmortizingPayment self)"},
	 { "AmortizingPayment_swigregister", AmortizingPayment_swigregister, METH_O, NULL},
	 { "AmortizingPayment_swiginit", AmortizingPayment_swiginit, METH_VARARGS, NULL},
	 { "new_IndexedCashFlow", _wrap_new_IndexedCashFlow, METH_VARARGS, "IndexedCashFlow(Real notional, ext::shared_ptr< Index > const & index, Date baseDate, Date fixingDate, Date paymentDate, bool growthOnly=False)"},
	 { "IndexedCashFlow_notional", _wrap_IndexedCashFlow_notional, METH_O, "IndexedCashFlow_notional(IndexedCashFlow self) -> Real"},
	 { "IndexedCashFlow_baseDate", _wrap_IndexedCashFlow_baseDate, METH_O, "IndexedCashFlow_baseDate(IndexedCashFlow self) -> Date"},
	 { "IndexedCashFlow_fixingDate", _wrap_IndexedCashFlow_fixingDate, METH_O, "IndexedCashFlow_fixingDate(IndexedCashFlow self) -> Date"},
	 { "IndexedCashFlow_baseFixing", _wrap_IndexedCashFlow_baseFixing, METH_O, "IndexedCashFlow_baseFixing(IndexedCashFlow self) -> Real"},
	 { "IndexedCashFlow_indexFixing", _wrap_IndexedCashFlow_indexFixing, METH_O, "IndexedCashFlow_indexFixing(IndexedCashFlow self) -> Real"},
	 { "IndexedCashFlow_index", _wrap_IndexedCashFlow_index, METH_O, "IndexedCashFlow_index(IndexedCashFlow self) -> ext::shared_ptr< Index >"},
	 { "IndexedCashFlow_growthOnly", _wrap_IndexedCashFlow_growthOnly, METH_O, "IndexedCashFlow_growthOnly(IndexedCashFlow self) -> bool"},
	 { "delete_IndexedCashFlow", _wrap_delete_IndexedCashFlow, METH_O, "delete_IndexedCashFlow(IndexedCashFlow self)"},
	 { "IndexedCashFlow_swigregister", IndexedCashFlow_swigregister, METH_O, NULL},
	 { "IndexedCashFlow_swiginit", IndexedCashFlow_swiginit, METH_VARARGS, NULL},
	 { "as_indexed_cashflow", _wrap_as_indexed_cashflow, METH_O, "as_indexed_cashflow(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< IndexedCashFlow >"},
	 { "Coupon_nominal", _wrap_Coupon_nominal, METH_O, "Coupon_nominal(Coupon self) -> Real"},
	 { "Coupon_accrualStartDate", _wrap_Coupon_accrualStartDate, METH_O, "Coupon_accrualStartDate(Coupon self) -> Date"},
	 { "Coupon_accrualEndDate", _wrap_Coupon_accrualEndDate, METH_O, "Coupon_accrualEndDate(Coupon self) -> Date"},
	 { "Coupon_referencePeriodStart", _wrap_Coupon_referencePeriodStart, METH_O, "Coupon_referencePeriodStart(Coupon self) -> Date"},
	 { "Coupon_referencePeriodEnd", _wrap_Coupon_referencePeriodEnd, METH_O, "Coupon_referencePeriodEnd(Coupon self) -> Date"},
	 { "Coupon_exCouponDate", _wrap_Coupon_exCouponDate, METH_O, "Coupon_exCouponDate(Coupon self) -> Date"},
	 { "Coupon_rate", _wrap_Coupon_rate, METH_O, "Coupon_rate(Coupon self) -> Real"},
	 { "Coupon_accrualPeriod", _wrap_Coupon_accrualPeriod, METH_O, "Coupon_accrualPeriod(Coupon self) -> Time"},
	 { "Coupon_accrualDays", _wrap_Coupon_accrualDays, METH_O, "Coupon_accrualDays(Coupon self) -> BigInteger"},
	 { "Coupon_dayCounter", _wrap_Coupon_dayCounter, METH_O, "Coupon_dayCounter(Coupon self) -> DayCounter"},
	 { "Coupon_accruedAmount", _wrap_Coupon_accruedAmount, METH_VARARGS, "Coupon_accruedAmount(Coupon self, Date date) -> Real"},
	 { "delete_Coupon", _wrap_delete_Coupon, METH_O, "delete_Coupon(Coupon self)"},
	 { "Coupon_swigregister", Coupon_swigregister, METH_O, NULL},
	 { "as_coupon", _wrap_as_coupon, METH_O, "as_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< Coupon >"},
	 { "new_FixedRateCoupon", (PyCFunction)(void(*)(void))_wrap_new_FixedRateCoupon, METH_VARARGS|METH_KEYWORDS, "new_FixedRateCoupon(Date paymentDate, Real nominal, Rate rate, DayCounter dayCounter, Date startDate, Date endDate, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date()) -> FixedRateCoupon"},
	 { "FixedRateCoupon_interestRate", _wrap_FixedRateCoupon_interestRate, METH_O, "FixedRateCoupon_interestRate(FixedRateCoupon self) -> InterestRate"},
	 { "delete_FixedRateCoupon", _wrap_delete_FixedRateCoupon, METH_O, "delete_FixedRateCoupon(FixedRateCoupon self)"},
	 { "FixedRateCoupon_swigregister", FixedRateCoupon_swigregister, METH_O, NULL},
	 { "FixedRateCoupon_swiginit", FixedRateCoupon_swiginit, METH_VARARGS, NULL},
	 { "as_fixed_rate_coupon", _wrap_as_fixed_rate_coupon, METH_O, "as_fixed_rate_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< FixedRateCoupon >"},
	 { "FloatingRateCouponPricer_swapletPrice", _wrap_FloatingRateCouponPricer_swapletPrice, METH_O, "FloatingRateCouponPricer_swapletPrice(FloatingRateCouponPricer self) -> Real"},
	 { "FloatingRateCouponPricer_swapletRate", _wrap_FloatingRateCouponPricer_swapletRate, METH_O, "FloatingRateCouponPricer_swapletRate(FloatingRateCouponPricer self) -> Rate"},
	 { "FloatingRateCouponPricer_capletPrice", _wrap_FloatingRateCouponPricer_capletPrice, METH_VARARGS, "FloatingRateCouponPricer_capletPrice(FloatingRateCouponPricer self, Rate effectiveCap) -> Real"},
	 { "FloatingRateCouponPricer_capletRate", _wrap_FloatingRateCouponPricer_capletRate, METH_VARARGS, "FloatingRateCouponPricer_capletRate(FloatingRateCouponPricer self, Rate effectiveCap) -> Rate"},
	 { "FloatingRateCouponPricer_floorletPrice", _wrap_FloatingRateCouponPricer_floorletPrice, METH_VARARGS, "FloatingRateCouponPricer_floorletPrice(FloatingRateCouponPricer self, Rate effectiveFloor) -> Real"},
	 { "FloatingRateCouponPricer_floorletRate", _wrap_FloatingRateCouponPricer_floorletRate, METH_VARARGS, "FloatingRateCouponPricer_floorletRate(FloatingRateCouponPricer self, Rate effectiveFloor) -> Rate"},
	 { "delete_FloatingRateCouponPricer", _wrap_delete_FloatingRateCouponPricer, METH_O, "delete_FloatingRateCouponPricer(FloatingRateCouponPricer self)"},
	 { "FloatingRateCouponPricer_swigregister", FloatingRateCouponPricer_swigregister, METH_O, NULL},
	 { "FloatingRateCoupon_fixingDate", _wrap_FloatingRateCoupon_fixingDate, METH_O, "FloatingRateCoupon_fixingDate(FloatingRateCoupon self) -> Date"},
	 { "FloatingRateCoupon_fixingDays", _wrap_FloatingRateCoupon_fixingDays, METH_O, "FloatingRateCoupon_fixingDays(FloatingRateCoupon self) -> Integer"},
	 { "FloatingRateCoupon_isInArrears", _wrap_FloatingRateCoupon_isInArrears, METH_O, "FloatingRateCoupon_isInArrears(FloatingRateCoupon self) -> bool"},
	 { "FloatingRateCoupon_gearing", _wrap_FloatingRateCoupon_gearing, METH_O, "FloatingRateCoupon_gearing(FloatingRateCoupon self) -> Real"},
	 { "FloatingRateCoupon_spread", _wrap_FloatingRateCoupon_spread, METH_O, "FloatingRateCoupon_spread(FloatingRateCoupon self) -> Rate"},
	 { "FloatingRateCoupon_indexFixing", _wrap_FloatingRateCoupon_indexFixing, METH_O, "FloatingRateCoupon_indexFixing(FloatingRateCoupon self) -> Rate"},
	 { "FloatingRateCoupon_adjustedFixing", _wrap_FloatingRateCoupon_adjustedFixing, METH_O, "FloatingRateCoupon_adjustedFixing(FloatingRateCoupon self) -> Rate"},
	 { "FloatingRateCoupon_convexityAdjustment", _wrap_FloatingRateCoupon_convexityAdjustment, METH_O, "FloatingRateCoupon_convexityAdjustment(FloatingRateCoupon self) -> Rate"},
	 { "FloatingRateCoupon_price", _wrap_FloatingRateCoupon_price, METH_VARARGS, "FloatingRateCoupon_price(FloatingRateCoupon self, YieldTermStructureHandle discountCurve) -> Real"},
	 { "FloatingRateCoupon_index", _wrap_FloatingRateCoupon_index, METH_O, "FloatingRateCoupon_index(FloatingRateCoupon self) -> ext::shared_ptr< InterestRateIndex >"},
	 { "FloatingRateCoupon_setPricer", _wrap_FloatingRateCoupon_setPricer, METH_VARARGS, "FloatingRateCoupon_setPricer(FloatingRateCoupon self, ext::shared_ptr< FloatingRateCouponPricer > const & p)"},
	 { "delete_FloatingRateCoupon", _wrap_delete_FloatingRateCoupon, METH_O, "delete_FloatingRateCoupon(FloatingRateCoupon self)"},
	 { "FloatingRateCoupon_swigregister", FloatingRateCoupon_swigregister, METH_O, NULL},
	 { "as_floating_rate_coupon", _wrap_as_floating_rate_coupon, METH_O, "as_floating_rate_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< FloatingRateCoupon >"},
	 { "new_RateAveraging", _wrap_new_RateAveraging, METH_NOARGS, "new_RateAveraging() -> RateAveraging"},
	 { "delete_RateAveraging", _wrap_delete_RateAveraging, METH_O, "delete_RateAveraging(RateAveraging self)"},
	 { "RateAveraging_swigregister", RateAveraging_swigregister, METH_O, NULL},
	 { "RateAveraging_swiginit", RateAveraging_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexedCoupon", _wrap_new_OvernightIndexedCoupon, METH_VARARGS, "OvernightIndexedCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< OvernightIndex > const & overnightIndex, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound)"},
	 { "OvernightIndexedCoupon_fixingDates", _wrap_OvernightIndexedCoupon_fixingDates, METH_O, "OvernightIndexedCoupon_fixingDates(OvernightIndexedCoupon self) -> DateVector"},
	 { "OvernightIndexedCoupon_dt", _wrap_OvernightIndexedCoupon_dt, METH_O, "OvernightIndexedCoupon_dt(OvernightIndexedCoupon self) -> DoubleVector"},
	 { "OvernightIndexedCoupon_indexFixings", _wrap_OvernightIndexedCoupon_indexFixings, METH_O, "OvernightIndexedCoupon_indexFixings(OvernightIndexedCoupon self) -> DoubleVector"},
	 { "OvernightIndexedCoupon_valueDates", _wrap_OvernightIndexedCoupon_valueDates, METH_O, "OvernightIndexedCoupon_valueDates(OvernightIndexedCoupon self) -> DateVector"},
	 { "delete_OvernightIndexedCoupon", _wrap_delete_OvernightIndexedCoupon, METH_O, "delete_OvernightIndexedCoupon(OvernightIndexedCoupon self)"},
	 { "OvernightIndexedCoupon_swigregister", OvernightIndexedCoupon_swigregister, METH_O, NULL},
	 { "OvernightIndexedCoupon_swiginit", OvernightIndexedCoupon_swiginit, METH_VARARGS, NULL},
	 { "as_overnight_indexed_coupon", _wrap_as_overnight_indexed_coupon, METH_O, "as_overnight_indexed_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< OvernightIndexedCoupon >"},
	 { "new_CappedFlooredCoupon", (PyCFunction)(void(*)(void))_wrap_new_CappedFlooredCoupon, METH_VARARGS|METH_KEYWORDS, "new_CappedFlooredCoupon(ext::shared_ptr< FloatingRateCoupon > const & underlying, Rate cap=Null< Rate >(), Rate floor=Null< Rate >()) -> CappedFlooredCoupon"},
	 { "CappedFlooredCoupon_cap", _wrap_CappedFlooredCoupon_cap, METH_O, "CappedFlooredCoupon_cap(CappedFlooredCoupon self) -> Rate"},
	 { "CappedFlooredCoupon_floor", _wrap_CappedFlooredCoupon_floor, METH_O, "CappedFlooredCoupon_floor(CappedFlooredCoupon self) -> Rate"},
	 { "CappedFlooredCoupon_effectiveCap", _wrap_CappedFlooredCoupon_effectiveCap, METH_O, "CappedFlooredCoupon_effectiveCap(CappedFlooredCoupon self) -> Rate"},
	 { "CappedFlooredCoupon_effectiveFloor", _wrap_CappedFlooredCoupon_effectiveFloor, METH_O, "CappedFlooredCoupon_effectiveFloor(CappedFlooredCoupon self) -> Rate"},
	 { "CappedFlooredCoupon_isCapped", _wrap_CappedFlooredCoupon_isCapped, METH_O, "CappedFlooredCoupon_isCapped(CappedFlooredCoupon self) -> bool"},
	 { "CappedFlooredCoupon_isFloored", _wrap_CappedFlooredCoupon_isFloored, METH_O, "CappedFlooredCoupon_isFloored(CappedFlooredCoupon self) -> bool"},
	 { "CappedFlooredCoupon_setPricer", _wrap_CappedFlooredCoupon_setPricer, METH_VARARGS, "CappedFlooredCoupon_setPricer(CappedFlooredCoupon self, ext::shared_ptr< FloatingRateCouponPricer > const & p)"},
	 { "delete_CappedFlooredCoupon", _wrap_delete_CappedFlooredCoupon, METH_O, "delete_CappedFlooredCoupon(CappedFlooredCoupon self)"},
	 { "CappedFlooredCoupon_swigregister", CappedFlooredCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredCoupon_swiginit", CappedFlooredCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_IborCoupon", (PyCFunction)(void(*)(void))_wrap_new_IborCoupon, METH_VARARGS|METH_KEYWORDS, "new_IborCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Integer fixingDays, ext::shared_ptr< IborIndex > & index, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> IborCoupon"},
	 { "IborCoupon_createAtParCoupons", _wrap_IborCoupon_createAtParCoupons, METH_NOARGS, "IborCoupon_createAtParCoupons()"},
	 { "IborCoupon_createIndexedCoupons", _wrap_IborCoupon_createIndexedCoupons, METH_NOARGS, "IborCoupon_createIndexedCoupons()"},
	 { "IborCoupon_usingAtParCoupons", _wrap_IborCoupon_usingAtParCoupons, METH_NOARGS, "IborCoupon_usingAtParCoupons() -> bool"},
	 { "delete_IborCoupon", _wrap_delete_IborCoupon, METH_O, "delete_IborCoupon(IborCoupon self)"},
	 { "IborCoupon_swigregister", IborCoupon_swigregister, METH_O, NULL},
	 { "IborCoupon_swiginit", IborCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_CappedFlooredIborCoupon", (PyCFunction)(void(*)(void))_wrap_new_CappedFlooredIborCoupon, METH_VARARGS|METH_KEYWORDS, "new_CappedFlooredIborCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Integer fixingDays, ext::shared_ptr< IborIndex > & index, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CappedFlooredIborCoupon"},
	 { "delete_CappedFlooredIborCoupon", _wrap_delete_CappedFlooredIborCoupon, METH_O, "delete_CappedFlooredIborCoupon(CappedFlooredIborCoupon self)"},
	 { "CappedFlooredIborCoupon_swigregister", CappedFlooredIborCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredIborCoupon_swiginit", CappedFlooredIborCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_SubPeriodsCoupon", (PyCFunction)(void(*)(void))_wrap_new_SubPeriodsCoupon, METH_VARARGS|METH_KEYWORDS, "new_SubPeriodsCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< IborIndex > const & index, Real gearing=1.0, Rate couponSpread=0.0, Rate rateSpread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), Date exCouponDate=Date()) -> SubPeriodsCoupon"},
	 { "SubPeriodsCoupon_fixingDates", _wrap_SubPeriodsCoupon_fixingDates, METH_O, "SubPeriodsCoupon_fixingDates(SubPeriodsCoupon self) -> DateVector"},
	 { "SubPeriodsCoupon_dt", _wrap_SubPeriodsCoupon_dt, METH_O, "SubPeriodsCoupon_dt(SubPeriodsCoupon self) -> DoubleVector"},
	 { "SubPeriodsCoupon_valueDates", _wrap_SubPeriodsCoupon_valueDates, METH_O, "SubPeriodsCoupon_valueDates(SubPeriodsCoupon self) -> DateVector"},
	 { "SubPeriodsCoupon_rateSpread", _wrap_SubPeriodsCoupon_rateSpread, METH_O, "SubPeriodsCoupon_rateSpread(SubPeriodsCoupon self) -> Spread"},
	 { "delete_SubPeriodsCoupon", _wrap_delete_SubPeriodsCoupon, METH_O, "delete_SubPeriodsCoupon(SubPeriodsCoupon self)"},
	 { "SubPeriodsCoupon_swigregister", SubPeriodsCoupon_swigregister, METH_O, NULL},
	 { "SubPeriodsCoupon_swiginit", SubPeriodsCoupon_swiginit, METH_VARARGS, NULL},
	 { "as_sub_periods_coupon", _wrap_as_sub_periods_coupon, METH_O, "as_sub_periods_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< SubPeriodsCoupon >"},
	 { "IborCouponPricer_capletVolatility", _wrap_IborCouponPricer_capletVolatility, METH_O, "IborCouponPricer_capletVolatility(IborCouponPricer self) -> OptionletVolatilityStructureHandle"},
	 { "IborCouponPricer_setCapletVolatility", _wrap_IborCouponPricer_setCapletVolatility, METH_VARARGS, "IborCouponPricer_setCapletVolatility(IborCouponPricer self, OptionletVolatilityStructureHandle v=Handle< OptionletVolatilityStructure >())"},
	 { "delete_IborCouponPricer", _wrap_delete_IborCouponPricer, METH_O, "delete_IborCouponPricer(IborCouponPricer self)"},
	 { "IborCouponPricer_swigregister", IborCouponPricer_swigregister, METH_O, NULL},
	 { "new_BlackIborCouponPricer", (PyCFunction)(void(*)(void))_wrap_new_BlackIborCouponPricer, METH_VARARGS|METH_KEYWORDS, "new_BlackIborCouponPricer(OptionletVolatilityStructureHandle v=Handle< OptionletVolatilityStructure >(), BlackIborCouponPricer::TimingAdjustment const timingAdjustment=Black76, QuoteHandle correlation=Handle< Quote >(ext::shared_ptr<Quote>(new SimpleQuote(1.0))), ext::optional< bool > useIndexedCoupon=ext::nullopt) -> BlackIborCouponPricer"},
	 { "delete_BlackIborCouponPricer", _wrap_delete_BlackIborCouponPricer, METH_O, "delete_BlackIborCouponPricer(BlackIborCouponPricer self)"},
	 { "BlackIborCouponPricer_swigregister", BlackIborCouponPricer_swigregister, METH_O, NULL},
	 { "BlackIborCouponPricer_swiginit", BlackIborCouponPricer_swiginit, METH_VARARGS, NULL},
	 { "delete_SubPeriodsPricer", _wrap_delete_SubPeriodsPricer, METH_O, "delete_SubPeriodsPricer(SubPeriodsPricer self)"},
	 { "SubPeriodsPricer_swigregister", SubPeriodsPricer_swigregister, METH_O, NULL},
	 { "new_CompoundingRatePricer", _wrap_new_CompoundingRatePricer, METH_NOARGS, "new_CompoundingRatePricer() -> CompoundingRatePricer"},
	 { "delete_CompoundingRatePricer", _wrap_delete_CompoundingRatePricer, METH_O, "delete_CompoundingRatePricer(CompoundingRatePricer self)"},
	 { "CompoundingRatePricer_swigregister", CompoundingRatePricer_swigregister, METH_O, NULL},
	 { "CompoundingRatePricer_swiginit", CompoundingRatePricer_swiginit, METH_VARARGS, NULL},
	 { "new_AveragingRatePricer", _wrap_new_AveragingRatePricer, METH_NOARGS, "new_AveragingRatePricer() -> AveragingRatePricer"},
	 { "delete_AveragingRatePricer", _wrap_delete_AveragingRatePricer, METH_O, "delete_AveragingRatePricer(AveragingRatePricer self)"},
	 { "AveragingRatePricer_swigregister", AveragingRatePricer_swigregister, METH_O, NULL},
	 { "AveragingRatePricer_swiginit", AveragingRatePricer_swiginit, METH_VARARGS, NULL},
	 { "new_CmsCoupon", (PyCFunction)(void(*)(void))_wrap_new_CmsCoupon, METH_VARARGS|METH_KEYWORDS, "new_CmsCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Integer fixingDays, ext::shared_ptr< SwapIndex > const & index, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CmsCoupon"},
	 { "delete_CmsCoupon", _wrap_delete_CmsCoupon, METH_O, "delete_CmsCoupon(CmsCoupon self)"},
	 { "CmsCoupon_swigregister", CmsCoupon_swigregister, METH_O, NULL},
	 { "CmsCoupon_swiginit", CmsCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_CmsSpreadCoupon", (PyCFunction)(void(*)(void))_wrap_new_CmsSpreadCoupon, METH_VARARGS|METH_KEYWORDS, "new_CmsSpreadCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< SwapSpreadIndex > const & index, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date()) -> CmsSpreadCoupon"},
	 { "delete_CmsSpreadCoupon", _wrap_delete_CmsSpreadCoupon, METH_O, "delete_CmsSpreadCoupon(CmsSpreadCoupon self)"},
	 { "CmsSpreadCoupon_swigregister", CmsSpreadCoupon_swigregister, METH_O, NULL},
	 { "CmsSpreadCoupon_swiginit", CmsSpreadCoupon_swiginit, METH_VARARGS, NULL},
	 { "CmsCouponPricer_swaptionVolatility", _wrap_CmsCouponPricer_swaptionVolatility, METH_O, "CmsCouponPricer_swaptionVolatility(CmsCouponPricer self) -> SwaptionVolatilityStructureHandle"},
	 { "CmsCouponPricer_setSwaptionVolatility", _wrap_CmsCouponPricer_setSwaptionVolatility, METH_VARARGS, "CmsCouponPricer_setSwaptionVolatility(CmsCouponPricer self, SwaptionVolatilityStructureHandle v=Handle< SwaptionVolatilityStructure >())"},
	 { "delete_CmsCouponPricer", _wrap_delete_CmsCouponPricer, METH_O, "delete_CmsCouponPricer(CmsCouponPricer self)"},
	 { "CmsCouponPricer_swigregister", CmsCouponPricer_swigregister, METH_O, NULL},
	 { "CmsCouponPricerVector_iterator", _wrap_CmsCouponPricerVector_iterator, METH_O, "CmsCouponPricerVector_iterator(CmsCouponPricerVector self) -> SwigPyIterator"},
	 { "CmsCouponPricerVector___nonzero__", _wrap_CmsCouponPricerVector___nonzero__, METH_O, "CmsCouponPricerVector___nonzero__(CmsCouponPricerVector self) -> bool"},
	 { "CmsCouponPricerVector___bool__", _wrap_CmsCouponPricerVector___bool__, METH_O, "CmsCouponPricerVector___bool__(CmsCouponPricerVector self) -> bool"},
	 { "CmsCouponPricerVector___len__", _wrap_CmsCouponPricerVector___len__, METH_O, "CmsCouponPricerVector___len__(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type"},
	 { "CmsCouponPricerVector___getslice__", _wrap_CmsCouponPricerVector___getslice__, METH_VARARGS, "CmsCouponPricerVector___getslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j) -> CmsCouponPricerVector"},
	 { "CmsCouponPricerVector___setslice__", _wrap_CmsCouponPricerVector___setslice__, METH_VARARGS, "\n"
		"CmsCouponPricerVector___setslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j)\n"
		"CmsCouponPricerVector___setslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j, CmsCouponPricerVector v)\n"
		""},
	 { "CmsCouponPricerVector___delslice__", _wrap_CmsCouponPricerVector___delslice__, METH_VARARGS, "CmsCouponPricerVector___delslice__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type j)"},
	 { "CmsCouponPricerVector___delitem__", _wrap_CmsCouponPricerVector___delitem__, METH_VARARGS, "\n"
		"CmsCouponPricerVector___delitem__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i)\n"
		"CmsCouponPricerVector___delitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "CmsCouponPricerVector___getitem__", _wrap_CmsCouponPricerVector___getitem__, METH_VARARGS, "\n"
		"CmsCouponPricerVector___getitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice) -> CmsCouponPricerVector\n"
		"CmsCouponPricerVector___getitem__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &\n"
		""},
	 { "CmsCouponPricerVector___setitem__", _wrap_CmsCouponPricerVector___setitem__, METH_VARARGS, "\n"
		"CmsCouponPricerVector___setitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice, CmsCouponPricerVector v)\n"
		"CmsCouponPricerVector___setitem__(CmsCouponPricerVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"CmsCouponPricerVector___setitem__(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::difference_type i, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)\n"
		""},
	 { "CmsCouponPricerVector_pop", _wrap_CmsCouponPricerVector_pop, METH_O, "CmsCouponPricerVector_pop(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type"},
	 { "CmsCouponPricerVector_append", _wrap_CmsCouponPricerVector_append, METH_VARARGS, "CmsCouponPricerVector_append(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)"},
	 { "CmsCouponPricerVector_empty", _wrap_CmsCouponPricerVector_empty, METH_O, "CmsCouponPricerVector_empty(CmsCouponPricerVector self) -> bool"},
	 { "CmsCouponPricerVector_size", _wrap_CmsCouponPricerVector_size, METH_O, "CmsCouponPricerVector_size(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type"},
	 { "CmsCouponPricerVector_swap", _wrap_CmsCouponPricerVector_swap, METH_VARARGS, "CmsCouponPricerVector_swap(CmsCouponPricerVector self, CmsCouponPricerVector v)"},
	 { "CmsCouponPricerVector_begin", _wrap_CmsCouponPricerVector_begin, METH_O, "CmsCouponPricerVector_begin(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator"},
	 { "CmsCouponPricerVector_end", _wrap_CmsCouponPricerVector_end, METH_O, "CmsCouponPricerVector_end(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator"},
	 { "CmsCouponPricerVector_rbegin", _wrap_CmsCouponPricerVector_rbegin, METH_O, "CmsCouponPricerVector_rbegin(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator"},
	 { "CmsCouponPricerVector_rend", _wrap_CmsCouponPricerVector_rend, METH_O, "CmsCouponPricerVector_rend(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::reverse_iterator"},
	 { "CmsCouponPricerVector_clear", _wrap_CmsCouponPricerVector_clear, METH_O, "CmsCouponPricerVector_clear(CmsCouponPricerVector self)"},
	 { "CmsCouponPricerVector_get_allocator", _wrap_CmsCouponPricerVector_get_allocator, METH_O, "CmsCouponPricerVector_get_allocator(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::allocator_type"},
	 { "CmsCouponPricerVector_pop_back", _wrap_CmsCouponPricerVector_pop_back, METH_O, "CmsCouponPricerVector_pop_back(CmsCouponPricerVector self)"},
	 { "CmsCouponPricerVector_erase", _wrap_CmsCouponPricerVector_erase, METH_VARARGS, "\n"
		"CmsCouponPricerVector_erase(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator\n"
		"CmsCouponPricerVector_erase(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator first, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator last) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator\n"
		""},
	 { "new_CmsCouponPricerVector", _wrap_new_CmsCouponPricerVector, METH_VARARGS, "\n"
		"CmsCouponPricerVector()\n"
		"CmsCouponPricerVector(CmsCouponPricerVector other)\n"
		"CmsCouponPricerVector(std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type size)\n"
		"new_CmsCouponPricerVector(std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type size, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & value) -> CmsCouponPricerVector\n"
		""},
	 { "CmsCouponPricerVector_push_back", _wrap_CmsCouponPricerVector_push_back, METH_VARARGS, "CmsCouponPricerVector_push_back(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)"},
	 { "CmsCouponPricerVector_front", _wrap_CmsCouponPricerVector_front, METH_O, "CmsCouponPricerVector_front(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &"},
	 { "CmsCouponPricerVector_back", _wrap_CmsCouponPricerVector_back, METH_O, "CmsCouponPricerVector_back(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const &"},
	 { "CmsCouponPricerVector_assign", _wrap_CmsCouponPricerVector_assign, METH_VARARGS, "CmsCouponPricerVector_assign(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)"},
	 { "CmsCouponPricerVector_resize", _wrap_CmsCouponPricerVector_resize, METH_VARARGS, "\n"
		"CmsCouponPricerVector_resize(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type new_size)\n"
		"CmsCouponPricerVector_resize(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type new_size, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)\n"
		""},
	 { "CmsCouponPricerVector_insert", _wrap_CmsCouponPricerVector_insert, METH_VARARGS, "\n"
		"CmsCouponPricerVector_insert(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator\n"
		"CmsCouponPricerVector_insert(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::iterator pos, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n, std::vector< ext::shared_ptr< CmsCouponPricer > >::value_type const & x)\n"
		""},
	 { "CmsCouponPricerVector_reserve", _wrap_CmsCouponPricerVector_reserve, METH_VARARGS, "CmsCouponPricerVector_reserve(CmsCouponPricerVector self, std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type n)"},
	 { "CmsCouponPricerVector_capacity", _wrap_CmsCouponPricerVector_capacity, METH_O, "CmsCouponPricerVector_capacity(CmsCouponPricerVector self) -> std::vector< ext::shared_ptr< CmsCouponPricer > >::size_type"},
	 { "delete_CmsCouponPricerVector", _wrap_delete_CmsCouponPricerVector, METH_O, "delete_CmsCouponPricerVector(CmsCouponPricerVector self)"},
	 { "CmsCouponPricerVector_swigregister", CmsCouponPricerVector_swigregister, METH_O, NULL},
	 { "CmsCouponPricerVector_swiginit", CmsCouponPricerVector_swiginit, METH_VARARGS, NULL},
	 { "delete_GFunctionFactory", _wrap_delete_GFunctionFactory, METH_O, "delete_GFunctionFactory(GFunctionFactory self)"},
	 { "GFunctionFactory_swigregister", GFunctionFactory_swigregister, METH_O, NULL},
	 { "new_AnalyticHaganPricer", _wrap_new_AnalyticHaganPricer, METH_VARARGS, "new_AnalyticHaganPricer(SwaptionVolatilityStructureHandle v, GFunctionFactory::YieldCurveModel model, QuoteHandle meanReversion) -> AnalyticHaganPricer"},
	 { "delete_AnalyticHaganPricer", _wrap_delete_AnalyticHaganPricer, METH_O, "delete_AnalyticHaganPricer(AnalyticHaganPricer self)"},
	 { "AnalyticHaganPricer_swigregister", AnalyticHaganPricer_swigregister, METH_O, NULL},
	 { "AnalyticHaganPricer_swiginit", AnalyticHaganPricer_swiginit, METH_VARARGS, NULL},
	 { "new_NumericHaganPricer", _wrap_new_NumericHaganPricer, METH_VARARGS, "NumericHaganPricer(SwaptionVolatilityStructureHandle v, GFunctionFactory::YieldCurveModel model, QuoteHandle meanReversion, Rate lowerLimit=0.0, Rate upperLimit=1.0, Real precision=1.0e-6)"},
	 { "delete_NumericHaganPricer", _wrap_delete_NumericHaganPricer, METH_O, "delete_NumericHaganPricer(NumericHaganPricer self)"},
	 { "NumericHaganPricer_swigregister", NumericHaganPricer_swigregister, METH_O, NULL},
	 { "NumericHaganPricer_swiginit", NumericHaganPricer_swiginit, METH_VARARGS, NULL},
	 { "new_CappedFlooredCmsCoupon", _wrap_new_CappedFlooredCmsCoupon, METH_VARARGS, "CappedFlooredCmsCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< SwapIndex > const & index, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date())"},
	 { "delete_CappedFlooredCmsCoupon", _wrap_delete_CappedFlooredCmsCoupon, METH_O, "delete_CappedFlooredCmsCoupon(CappedFlooredCmsCoupon self)"},
	 { "CappedFlooredCmsCoupon_swigregister", CappedFlooredCmsCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredCmsCoupon_swiginit", CappedFlooredCmsCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_CappedFlooredCmsSpreadCoupon", _wrap_new_CappedFlooredCmsSpreadCoupon, METH_VARARGS, "CappedFlooredCmsSpreadCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< SwapSpreadIndex > const & index, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date(), DayCounter dayCounter=DayCounter(), bool isInArrears=False, Date exCouponDate=Date())"},
	 { "delete_CappedFlooredCmsSpreadCoupon", _wrap_delete_CappedFlooredCmsSpreadCoupon, METH_O, "delete_CappedFlooredCmsSpreadCoupon(CappedFlooredCmsSpreadCoupon self)"},
	 { "CappedFlooredCmsSpreadCoupon_swigregister", CappedFlooredCmsSpreadCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredCmsSpreadCoupon_swiginit", CappedFlooredCmsSpreadCoupon_swiginit, METH_VARARGS, NULL},
	 { "new_LinearTsrPricer", _wrap_new_LinearTsrPricer, METH_VARARGS, "LinearTsrPricer(SwaptionVolatilityStructureHandle swaptionVol, QuoteHandle meanReversion, YieldTermStructureHandle couponDiscountCurve=Handle< YieldTermStructure >(), LinearTsrPricerSettings settings=LinearTsrPricer::Settings())"},
	 { "delete_LinearTsrPricer", _wrap_delete_LinearTsrPricer, METH_O, "delete_LinearTsrPricer(LinearTsrPricer self)"},
	 { "LinearTsrPricer_swigregister", LinearTsrPricer_swigregister, METH_O, NULL},
	 { "LinearTsrPricer_swiginit", LinearTsrPricer_swiginit, METH_VARARGS, NULL},
	 { "new_LinearTsrPricerSettings", _wrap_new_LinearTsrPricerSettings, METH_NOARGS, "new_LinearTsrPricerSettings() -> LinearTsrPricerSettings"},
	 { "LinearTsrPricerSettings_withRateBound", _wrap_LinearTsrPricerSettings_withRateBound, METH_VARARGS, "LinearTsrPricerSettings_withRateBound(LinearTsrPricerSettings self, Real const lowerRateBound=0.0001, Real const upperRateBound=2.0000) -> LinearTsrPricerSettings"},
	 { "LinearTsrPricerSettings_withVegaRatio", _wrap_LinearTsrPricerSettings_withVegaRatio, METH_VARARGS, "\n"
		"LinearTsrPricerSettings_withVegaRatio(LinearTsrPricerSettings self, Real const vegaRatio=0.01) -> LinearTsrPricerSettings\n"
		"LinearTsrPricerSettings_withVegaRatio(LinearTsrPricerSettings self, Real const vegaRatio, Real const lowerRateBound, Real const upperRateBound) -> LinearTsrPricerSettings\n"
		""},
	 { "LinearTsrPricerSettings_withPriceThreshold", _wrap_LinearTsrPricerSettings_withPriceThreshold, METH_VARARGS, "\n"
		"LinearTsrPricerSettings_withPriceThreshold(LinearTsrPricerSettings self, Real const priceThreshold=1.0E-8) -> LinearTsrPricerSettings\n"
		"LinearTsrPricerSettings_withPriceThreshold(LinearTsrPricerSettings self, Real const priceThreshold, Real const lowerRateBound, Real const upperRateBound) -> LinearTsrPricerSettings\n"
		""},
	 { "LinearTsrPricerSettings_withBSStdDevs", _wrap_LinearTsrPricerSettings_withBSStdDevs, METH_VARARGS, "\n"
		"LinearTsrPricerSettings_withBSStdDevs(LinearTsrPricerSettings self, Real const stdDevs=3.0) -> LinearTsrPricerSettings\n"
		"LinearTsrPricerSettings_withBSStdDevs(LinearTsrPricerSettings self, Real const stdDevs, Real const lowerRateBound, Real const upperRateBound) -> LinearTsrPricerSettings\n"
		""},
	 { "delete_LinearTsrPricerSettings", _wrap_delete_LinearTsrPricerSettings, METH_O, "delete_LinearTsrPricerSettings(LinearTsrPricerSettings self)"},
	 { "LinearTsrPricerSettings_swigregister", LinearTsrPricerSettings_swigregister, METH_O, NULL},
	 { "LinearTsrPricerSettings_swiginit", LinearTsrPricerSettings_swiginit, METH_VARARGS, NULL},
	 { "CmsSpreadCouponPricer_correlation", _wrap_CmsSpreadCouponPricer_correlation, METH_O, "CmsSpreadCouponPricer_correlation(CmsSpreadCouponPricer self) -> QuoteHandle"},
	 { "CmsSpreadCouponPricer_setCorrelation", _wrap_CmsSpreadCouponPricer_setCorrelation, METH_VARARGS, "CmsSpreadCouponPricer_setCorrelation(CmsSpreadCouponPricer self, QuoteHandle correlation=Handle< Quote >())"},
	 { "delete_CmsSpreadCouponPricer", _wrap_delete_CmsSpreadCouponPricer, METH_O, "delete_CmsSpreadCouponPricer(CmsSpreadCouponPricer self)"},
	 { "CmsSpreadCouponPricer_swigregister", CmsSpreadCouponPricer_swigregister, METH_O, NULL},
	 { "new_LognormalCmsSpreadPricer", _wrap_new_LognormalCmsSpreadPricer, METH_VARARGS, "LognormalCmsSpreadPricer(ext::shared_ptr< CmsCouponPricer > const & cmsPricer, QuoteHandle correlation, YieldTermStructureHandle couponDiscountCurve=Handle< YieldTermStructure >(), Size const IntegrationPoints=16, ext::optional< VolatilityType > const volatilityType=ext::nullopt, Real const shift1=Null< Real >(), Real const shift2=Null< Real >())"},
	 { "LognormalCmsSpreadPricer_swapletPrice", _wrap_LognormalCmsSpreadPricer_swapletPrice, METH_O, "LognormalCmsSpreadPricer_swapletPrice(LognormalCmsSpreadPricer self) -> Real"},
	 { "LognormalCmsSpreadPricer_swapletRate", _wrap_LognormalCmsSpreadPricer_swapletRate, METH_O, "LognormalCmsSpreadPricer_swapletRate(LognormalCmsSpreadPricer self) -> Rate"},
	 { "LognormalCmsSpreadPricer_capletPrice", _wrap_LognormalCmsSpreadPricer_capletPrice, METH_VARARGS, "LognormalCmsSpreadPricer_capletPrice(LognormalCmsSpreadPricer self, Rate effectiveCap) -> Real"},
	 { "LognormalCmsSpreadPricer_capletRate", _wrap_LognormalCmsSpreadPricer_capletRate, METH_VARARGS, "LognormalCmsSpreadPricer_capletRate(LognormalCmsSpreadPricer self, Rate effectiveCap) -> Rate"},
	 { "LognormalCmsSpreadPricer_floorletPrice", _wrap_LognormalCmsSpreadPricer_floorletPrice, METH_VARARGS, "LognormalCmsSpreadPricer_floorletPrice(LognormalCmsSpreadPricer self, Rate effectiveFloor) -> Real"},
	 { "LognormalCmsSpreadPricer_floorletRate", _wrap_LognormalCmsSpreadPricer_floorletRate, METH_VARARGS, "LognormalCmsSpreadPricer_floorletRate(LognormalCmsSpreadPricer self, Rate effectiveFloor) -> Rate"},
	 { "delete_LognormalCmsSpreadPricer", _wrap_delete_LognormalCmsSpreadPricer, METH_O, "delete_LognormalCmsSpreadPricer(LognormalCmsSpreadPricer self)"},
	 { "LognormalCmsSpreadPricer_swigregister", LognormalCmsSpreadPricer_swigregister, METH_O, NULL},
	 { "LognormalCmsSpreadPricer_swiginit", LognormalCmsSpreadPricer_swiginit, METH_VARARGS, NULL},
	 { "delete_EquityCashFlowPricer", _wrap_delete_EquityCashFlowPricer, METH_O, "delete_EquityCashFlowPricer(EquityCashFlowPricer self)"},
	 { "EquityCashFlowPricer_swigregister", EquityCashFlowPricer_swigregister, METH_O, NULL},
	 { "new_EquityCashFlow", _wrap_new_EquityCashFlow, METH_VARARGS, "EquityCashFlow(Real notional, ext::shared_ptr< EquityIndex > index, Date baseDate, Date fixingDate, Date paymentDate, bool growthOnly=True)"},
	 { "EquityCashFlow_setPricer", _wrap_EquityCashFlow_setPricer, METH_VARARGS, "EquityCashFlow_setPricer(EquityCashFlow self, ext::shared_ptr< EquityCashFlowPricer > const & arg2)"},
	 { "delete_EquityCashFlow", _wrap_delete_EquityCashFlow, METH_O, "delete_EquityCashFlow(EquityCashFlow self)"},
	 { "EquityCashFlow_swigregister", EquityCashFlow_swigregister, METH_O, NULL},
	 { "EquityCashFlow_swiginit", EquityCashFlow_swiginit, METH_VARARGS, NULL},
	 { "new_EquityQuantoCashFlowPricer", _wrap_new_EquityQuantoCashFlowPricer, METH_VARARGS, "new_EquityQuantoCashFlowPricer(YieldTermStructureHandle quantoCurrencyTermStructure, BlackVolTermStructureHandle equityVolatility, BlackVolTermStructureHandle fxVolatility, QuoteHandle correlation) -> EquityQuantoCashFlowPricer"},
	 { "delete_EquityQuantoCashFlowPricer", _wrap_delete_EquityQuantoCashFlowPricer, METH_O, "delete_EquityQuantoCashFlowPricer(EquityQuantoCashFlowPricer self)"},
	 { "EquityQuantoCashFlowPricer_swigregister", EquityQuantoCashFlowPricer_swigregister, METH_O, NULL},
	 { "EquityQuantoCashFlowPricer_swiginit", EquityQuantoCashFlowPricer_swiginit, METH_VARARGS, NULL},
	 { "FixedRateLeg", (PyCFunction)(void(*)(void))_wrap_FixedRateLeg, METH_VARARGS|METH_KEYWORDS, "FixedRateLeg(Schedule schedule, DayCounter dayCount, DoubleVector nominals, DoubleVector couponRates, BusinessDayConvention paymentAdjustment=Following, DayCounter firstPeriodDayCount=DayCounter(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, Calendar paymentCalendar=Calendar(), Integer paymentLag=0, Compounding compounding=Simple, Frequency compoundingFrequency=Annual) -> Leg"},
	 { "IborLeg", (PyCFunction)(void(*)(void))_wrap_IborLeg, METH_VARARGS|METH_KEYWORDS, "IborLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool isInArrears=False, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, Calendar paymentCalendar=Calendar(), Integer paymentLag=0, ext::optional< bool > withIndexedCoupons=ext::nullopt) -> Leg"},
	 { "OvernightLeg", (PyCFunction)(void(*)(void))_wrap_OvernightLeg, METH_VARARGS|METH_KEYWORDS, "OvernightLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< OvernightIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound, Calendar paymentCalendar=Calendar(), Integer paymentLag=0) -> Leg"},
	 { "CmsLeg", (PyCFunction)(void(*)(void))_wrap_CmsLeg, METH_VARARGS|METH_KEYWORDS, "CmsLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool isInArrears=False, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> Leg"},
	 { "CmsZeroLeg", (PyCFunction)(void(*)(void))_wrap_CmsZeroLeg, METH_VARARGS|METH_KEYWORDS, "CmsZeroLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> Leg"},
	 { "CmsSpreadLeg", (PyCFunction)(void(*)(void))_wrap_CmsSpreadLeg, METH_VARARGS|METH_KEYWORDS, "CmsSpreadLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< SwapSpreadIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool isInArrears=False) -> Leg"},
	 { "SubPeriodsLeg", (PyCFunction)(void(*)(void))_wrap_SubPeriodsLeg, METH_VARARGS|METH_KEYWORDS, "SubPeriodsLeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, Calendar paymentCalendar=Calendar(), Integer paymentLag=0, UnsignedIntVector fixingDays=std::vector< Natural >(), DoubleVector gearings=std::vector< Real >(), DoubleVector couponSpreads=std::vector< Spread >(), DoubleVector rateSpreads=std::vector< Spread >(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, RateAveraging::Type averagingMethod=Compound) -> Leg"},
	 { "new_Duration", _wrap_new_Duration, METH_NOARGS, "new_Duration() -> Duration"},
	 { "delete_Duration", _wrap_delete_Duration, METH_O, "delete_Duration(Duration self)"},
	 { "Duration_swigregister", Duration_swigregister, METH_O, NULL},
	 { "Duration_swiginit", Duration_swiginit, METH_VARARGS, NULL},
	 { "CashFlows_startDate", _wrap_CashFlows_startDate, METH_O, "CashFlows_startDate(Leg arg1) -> Date"},
	 { "CashFlows_maturityDate", _wrap_CashFlows_maturityDate, METH_O, "CashFlows_maturityDate(Leg arg1) -> Date"},
	 { "CashFlows_previousCashFlowDate", _wrap_CashFlows_previousCashFlowDate, METH_VARARGS, "CashFlows_previousCashFlowDate(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Date"},
	 { "CashFlows_nextCashFlowDate", _wrap_CashFlows_nextCashFlowDate, METH_VARARGS, "CashFlows_nextCashFlowDate(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Date"},
	 { "CashFlows_previousCashFlowAmount", _wrap_CashFlows_previousCashFlowAmount, METH_VARARGS, "CashFlows_previousCashFlowAmount(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Real"},
	 { "CashFlows_nextCashFlowAmount", _wrap_CashFlows_nextCashFlowAmount, METH_VARARGS, "CashFlows_nextCashFlowAmount(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Real"},
	 { "CashFlows_previousCashFlow", _wrap_CashFlows_previousCashFlow, METH_VARARGS, "CashFlows_previousCashFlow(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> ext::shared_ptr< CashFlow >"},
	 { "CashFlows_nextCashFlow", _wrap_CashFlows_nextCashFlow, METH_VARARGS, "CashFlows_nextCashFlow(Leg leg, bool includeSettlementDateFlows, Date settlementDate=Date()) -> ext::shared_ptr< CashFlow >"},
	 { "CashFlows_npv", _wrap_CashFlows_npv, METH_VARARGS, "\n"
		"CashFlows_npv(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, Spread zSpread, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_npv(Leg leg, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_npv(Leg arg1, InterestRate arg2, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_npv(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		""},
	 { "CashFlows_bps", _wrap_CashFlows_bps, METH_VARARGS, "\n"
		"CashFlows_bps(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_bps(Leg leg, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_bps(Leg arg1, InterestRate arg2, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_bps(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		""},
	 { "CashFlows_npvbps", _wrap_CashFlows_npvbps, METH_VARARGS, "\n"
		"CashFlows_npvbps(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> DoublePair\n"
		"CashFlows_npvbps(Leg leg, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> DoublePair\n"
		""},
	 { "CashFlows_atmRate", _wrap_CashFlows_atmRate, METH_VARARGS, "CashFlows_atmRate(Leg leg, ext::shared_ptr< YieldTermStructure > const & discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date(), Real npv=Null< Real >()) -> Rate"},
	 { "CashFlows_yieldRate", _wrap_CashFlows_yieldRate, METH_VARARGS, "CashFlows_yieldRate(Leg arg1, Real npv, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date(), Real accuracy=1.0e-10, Size maxIterations=10000, Rate guess=0.05) -> Rate"},
	 { "CashFlows_duration", _wrap_CashFlows_duration, METH_VARARGS, "\n"
		"CashFlows_duration(Leg arg1, InterestRate arg2, Duration::Type type, bool includeSettlementDateFlows, Date settlementDate=Date()) -> Time\n"
		"CashFlows_duration(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Duration::Type type, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Time\n"
		""},
	 { "CashFlows_convexity", _wrap_CashFlows_convexity, METH_VARARGS, "\n"
		"CashFlows_convexity(Leg arg1, InterestRate arg2, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_convexity(Leg arg1, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		""},
	 { "CashFlows_basisPointValue", _wrap_CashFlows_basisPointValue, METH_VARARGS, "\n"
		"CashFlows_basisPointValue(Leg leg, InterestRate _yield, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		"CashFlows_basisPointValue(Leg leg, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date()) -> Real\n"
		""},
	 { "CashFlows_zSpread", _wrap_CashFlows_zSpread, METH_VARARGS, "CashFlows_zSpread(Leg leg, Real npv, ext::shared_ptr< YieldTermStructure > const & arg3, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date(), Real accuracy=1.0e-10, Size maxIterations=100, Rate guess=0.0) -> Spread"},
	 { "delete_CashFlows", _wrap_delete_CashFlows, METH_O, "delete_CashFlows(CashFlows self)"},
	 { "CashFlows_swigregister", CashFlows_swigregister, METH_O, NULL},
	 { "delete_Dividend", _wrap_delete_Dividend, METH_O, "delete_Dividend(Dividend self)"},
	 { "Dividend_swigregister", Dividend_swigregister, METH_O, NULL},
	 { "new_FixedDividend", _wrap_new_FixedDividend, METH_VARARGS, "new_FixedDividend(Real amount, Date date) -> FixedDividend"},
	 { "delete_FixedDividend", _wrap_delete_FixedDividend, METH_O, "delete_FixedDividend(FixedDividend self)"},
	 { "FixedDividend_swigregister", FixedDividend_swigregister, METH_O, NULL},
	 { "FixedDividend_swiginit", FixedDividend_swiginit, METH_VARARGS, NULL},
	 { "new_FractionalDividend", _wrap_new_FractionalDividend, METH_VARARGS, "new_FractionalDividend(Rate rate, Date date) -> FractionalDividend"},
	 { "delete_FractionalDividend", _wrap_delete_FractionalDividend, METH_O, "delete_FractionalDividend(FractionalDividend self)"},
	 { "FractionalDividend_swigregister", FractionalDividend_swigregister, METH_O, NULL},
	 { "FractionalDividend_swiginit", FractionalDividend_swiginit, METH_VARARGS, NULL},
	 { "DividendSchedule_iterator", _wrap_DividendSchedule_iterator, METH_O, "DividendSchedule_iterator(DividendSchedule self) -> SwigPyIterator"},
	 { "DividendSchedule___nonzero__", _wrap_DividendSchedule___nonzero__, METH_O, "DividendSchedule___nonzero__(DividendSchedule self) -> bool"},
	 { "DividendSchedule___bool__", _wrap_DividendSchedule___bool__, METH_O, "DividendSchedule___bool__(DividendSchedule self) -> bool"},
	 { "DividendSchedule___len__", _wrap_DividendSchedule___len__, METH_O, "DividendSchedule___len__(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::size_type"},
	 { "DividendSchedule___getslice__", _wrap_DividendSchedule___getslice__, METH_VARARGS, "DividendSchedule___getslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j) -> DividendSchedule"},
	 { "DividendSchedule___setslice__", _wrap_DividendSchedule___setslice__, METH_VARARGS, "\n"
		"DividendSchedule___setslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j)\n"
		"DividendSchedule___setslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j, DividendSchedule v)\n"
		""},
	 { "DividendSchedule___delslice__", _wrap_DividendSchedule___delslice__, METH_VARARGS, "DividendSchedule___delslice__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::difference_type j)"},
	 { "DividendSchedule___delitem__", _wrap_DividendSchedule___delitem__, METH_VARARGS, "\n"
		"DividendSchedule___delitem__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i)\n"
		"DividendSchedule___delitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "DividendSchedule___getitem__", _wrap_DividendSchedule___getitem__, METH_VARARGS, "\n"
		"DividendSchedule___getitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice) -> DividendSchedule\n"
		"DividendSchedule___getitem__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i) -> std::vector< ext::shared_ptr< Dividend > >::value_type const &\n"
		""},
	 { "DividendSchedule___setitem__", _wrap_DividendSchedule___setitem__, METH_VARARGS, "\n"
		"DividendSchedule___setitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice, DividendSchedule v)\n"
		"DividendSchedule___setitem__(DividendSchedule self, SWIGPY_SLICEOBJECT * slice)\n"
		"DividendSchedule___setitem__(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::difference_type i, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)\n"
		""},
	 { "DividendSchedule_pop", _wrap_DividendSchedule_pop, METH_O, "DividendSchedule_pop(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::value_type"},
	 { "DividendSchedule_append", _wrap_DividendSchedule_append, METH_VARARGS, "DividendSchedule_append(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)"},
	 { "DividendSchedule_empty", _wrap_DividendSchedule_empty, METH_O, "DividendSchedule_empty(DividendSchedule self) -> bool"},
	 { "DividendSchedule_size", _wrap_DividendSchedule_size, METH_O, "DividendSchedule_size(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::size_type"},
	 { "DividendSchedule_swap", _wrap_DividendSchedule_swap, METH_VARARGS, "DividendSchedule_swap(DividendSchedule self, DividendSchedule v)"},
	 { "DividendSchedule_begin", _wrap_DividendSchedule_begin, METH_O, "DividendSchedule_begin(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::iterator"},
	 { "DividendSchedule_end", _wrap_DividendSchedule_end, METH_O, "DividendSchedule_end(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::iterator"},
	 { "DividendSchedule_rbegin", _wrap_DividendSchedule_rbegin, METH_O, "DividendSchedule_rbegin(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::reverse_iterator"},
	 { "DividendSchedule_rend", _wrap_DividendSchedule_rend, METH_O, "DividendSchedule_rend(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::reverse_iterator"},
	 { "DividendSchedule_clear", _wrap_DividendSchedule_clear, METH_O, "DividendSchedule_clear(DividendSchedule self)"},
	 { "DividendSchedule_get_allocator", _wrap_DividendSchedule_get_allocator, METH_O, "DividendSchedule_get_allocator(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::allocator_type"},
	 { "DividendSchedule_pop_back", _wrap_DividendSchedule_pop_back, METH_O, "DividendSchedule_pop_back(DividendSchedule self)"},
	 { "DividendSchedule_erase", _wrap_DividendSchedule_erase, METH_VARARGS, "\n"
		"DividendSchedule_erase(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator pos) -> std::vector< ext::shared_ptr< Dividend > >::iterator\n"
		"DividendSchedule_erase(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator first, std::vector< ext::shared_ptr< Dividend > >::iterator last) -> std::vector< ext::shared_ptr< Dividend > >::iterator\n"
		""},
	 { "new_DividendSchedule", _wrap_new_DividendSchedule, METH_VARARGS, "\n"
		"DividendSchedule()\n"
		"DividendSchedule(DividendSchedule other)\n"
		"DividendSchedule(std::vector< ext::shared_ptr< Dividend > >::size_type size)\n"
		"new_DividendSchedule(std::vector< ext::shared_ptr< Dividend > >::size_type size, std::vector< ext::shared_ptr< Dividend > >::value_type const & value) -> DividendSchedule\n"
		""},
	 { "DividendSchedule_push_back", _wrap_DividendSchedule_push_back, METH_VARARGS, "DividendSchedule_push_back(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)"},
	 { "DividendSchedule_front", _wrap_DividendSchedule_front, METH_O, "DividendSchedule_front(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::value_type const &"},
	 { "DividendSchedule_back", _wrap_DividendSchedule_back, METH_O, "DividendSchedule_back(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::value_type const &"},
	 { "DividendSchedule_assign", _wrap_DividendSchedule_assign, METH_VARARGS, "DividendSchedule_assign(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type n, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)"},
	 { "DividendSchedule_resize", _wrap_DividendSchedule_resize, METH_VARARGS, "\n"
		"DividendSchedule_resize(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type new_size)\n"
		"DividendSchedule_resize(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type new_size, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)\n"
		""},
	 { "DividendSchedule_insert", _wrap_DividendSchedule_insert, METH_VARARGS, "\n"
		"DividendSchedule_insert(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator pos, std::vector< ext::shared_ptr< Dividend > >::value_type const & x) -> std::vector< ext::shared_ptr< Dividend > >::iterator\n"
		"DividendSchedule_insert(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::iterator pos, std::vector< ext::shared_ptr< Dividend > >::size_type n, std::vector< ext::shared_ptr< Dividend > >::value_type const & x)\n"
		""},
	 { "DividendSchedule_reserve", _wrap_DividendSchedule_reserve, METH_VARARGS, "DividendSchedule_reserve(DividendSchedule self, std::vector< ext::shared_ptr< Dividend > >::size_type n)"},
	 { "DividendSchedule_capacity", _wrap_DividendSchedule_capacity, METH_O, "DividendSchedule_capacity(DividendSchedule self) -> std::vector< ext::shared_ptr< Dividend > >::size_type"},
	 { "delete_DividendSchedule", _wrap_delete_DividendSchedule, METH_O, "delete_DividendSchedule(DividendSchedule self)"},
	 { "DividendSchedule_swigregister", DividendSchedule_swigregister, METH_O, NULL},
	 { "DividendSchedule_swiginit", DividendSchedule_swiginit, METH_VARARGS, NULL},
	 { "new_Exercise", _wrap_new_Exercise, METH_O, "new_Exercise(Exercise::Type type) -> Exercise"},
	 { "Exercise_type", _wrap_Exercise_type, METH_O, "Exercise_type(Exercise self) -> Exercise::Type"},
	 { "Exercise_date", _wrap_Exercise_date, METH_VARARGS, "Exercise_date(Exercise self, Size index) -> Date"},
	 { "Exercise_dateAt", _wrap_Exercise_dateAt, METH_VARARGS, "Exercise_dateAt(Exercise self, Size index) -> Date"},
	 { "Exercise_dates", _wrap_Exercise_dates, METH_O, "Exercise_dates(Exercise self) -> DateVector"},
	 { "Exercise_lastDate", _wrap_Exercise_lastDate, METH_O, "Exercise_lastDate(Exercise self) -> Date"},
	 { "delete_Exercise", _wrap_delete_Exercise, METH_O, "delete_Exercise(Exercise self)"},
	 { "Exercise_swigregister", Exercise_swigregister, METH_O, NULL},
	 { "Exercise_swiginit", Exercise_swiginit, METH_VARARGS, NULL},
	 { "new_EuropeanExercise", _wrap_new_EuropeanExercise, METH_O, "new_EuropeanExercise(Date date) -> EuropeanExercise"},
	 { "delete_EuropeanExercise", _wrap_delete_EuropeanExercise, METH_O, "delete_EuropeanExercise(EuropeanExercise self)"},
	 { "EuropeanExercise_swigregister", EuropeanExercise_swigregister, METH_O, NULL},
	 { "EuropeanExercise_swiginit", EuropeanExercise_swiginit, METH_VARARGS, NULL},
	 { "new_AmericanExercise", _wrap_new_AmericanExercise, METH_VARARGS, "AmericanExercise(Date earliestDate, Date latestDate, bool payoffAtExpiry=False)"},
	 { "delete_AmericanExercise", _wrap_delete_AmericanExercise, METH_O, "delete_AmericanExercise(AmericanExercise self)"},
	 { "AmericanExercise_swigregister", AmericanExercise_swigregister, METH_O, NULL},
	 { "AmericanExercise_swiginit", AmericanExercise_swiginit, METH_VARARGS, NULL},
	 { "new_BermudanExercise", _wrap_new_BermudanExercise, METH_VARARGS, "BermudanExercise(DateVector dates, bool payoffAtExpiry=False)"},
	 { "delete_BermudanExercise", _wrap_delete_BermudanExercise, METH_O, "delete_BermudanExercise(BermudanExercise self)"},
	 { "BermudanExercise_swigregister", BermudanExercise_swigregister, METH_O, NULL},
	 { "BermudanExercise_swiginit", BermudanExercise_swiginit, METH_VARARGS, NULL},
	 { "new_RebatedExercise", _wrap_new_RebatedExercise, METH_VARARGS, "RebatedExercise(Exercise exercise, DoubleVector rebates, Natural rebateSettlementDays=0, Calendar rebatePaymentCalendar=NullCalendar(), BusinessDayConvention const rebatePaymentConvention=Following)"},
	 { "delete_RebatedExercise", _wrap_delete_RebatedExercise, METH_O, "delete_RebatedExercise(RebatedExercise self)"},
	 { "RebatedExercise_swigregister", RebatedExercise_swigregister, METH_O, NULL},
	 { "RebatedExercise_swiginit", RebatedExercise_swiginit, METH_VARARGS, NULL},
	 { "new_SwingExercise", _wrap_new_SwingExercise, METH_O, "new_SwingExercise(DateVector dates) -> SwingExercise"},
	 { "delete_SwingExercise", _wrap_delete_SwingExercise, METH_O, "delete_SwingExercise(SwingExercise self)"},
	 { "SwingExercise_swigregister", SwingExercise_swigregister, METH_O, NULL},
	 { "SwingExercise_swiginit", SwingExercise_swiginit, METH_VARARGS, NULL},
	 { "new_TimeGrid", _wrap_new_TimeGrid, METH_VARARGS, "\n"
		"TimeGrid()\n"
		"TimeGrid(Time end, Size steps)\n"
		"TimeGrid(DoubleVector times)\n"
		"new_TimeGrid(DoubleVector times, Size steps) -> TimeGrid\n"
		""},
	 { "TimeGrid___len__", _wrap_TimeGrid___len__, METH_O, "TimeGrid___len__(TimeGrid self) -> Size"},
	 { "TimeGrid___getitem__", _wrap_TimeGrid___getitem__, METH_VARARGS, "TimeGrid___getitem__(TimeGrid self, Integer i) -> Time"},
	 { "TimeGrid_dt", _wrap_TimeGrid_dt, METH_VARARGS, "TimeGrid_dt(TimeGrid self, Integer i) -> Time"},
	 { "delete_TimeGrid", _wrap_delete_TimeGrid, METH_O, "delete_TimeGrid(TimeGrid self)"},
	 { "TimeGrid_swigregister", TimeGrid_swigregister, METH_O, NULL},
	 { "TimeGrid_swiginit", TimeGrid_swiginit, METH_VARARGS, NULL},
	 { "StochasticProcess_size", _wrap_StochasticProcess_size, METH_O, "StochasticProcess_size(StochasticProcess self) -> Size"},
	 { "StochasticProcess_factors", _wrap_StochasticProcess_factors, METH_O, "StochasticProcess_factors(StochasticProcess self) -> Size"},
	 { "StochasticProcess_initialValues", _wrap_StochasticProcess_initialValues, METH_O, "StochasticProcess_initialValues(StochasticProcess self) -> Array"},
	 { "StochasticProcess_drift", _wrap_StochasticProcess_drift, METH_VARARGS, "StochasticProcess_drift(StochasticProcess self, Time t, Array x) -> Array"},
	 { "StochasticProcess_diffusion", _wrap_StochasticProcess_diffusion, METH_VARARGS, "StochasticProcess_diffusion(StochasticProcess self, Time t, Array x) -> Matrix"},
	 { "StochasticProcess_expectation", _wrap_StochasticProcess_expectation, METH_VARARGS, "StochasticProcess_expectation(StochasticProcess self, Time t0, Array x0, Time dt) -> Array"},
	 { "StochasticProcess_stdDeviation", _wrap_StochasticProcess_stdDeviation, METH_VARARGS, "StochasticProcess_stdDeviation(StochasticProcess self, Time t0, Array x0, Time dt) -> Matrix"},
	 { "StochasticProcess_covariance", _wrap_StochasticProcess_covariance, METH_VARARGS, "StochasticProcess_covariance(StochasticProcess self, Time t0, Array x0, Time dt) -> Matrix"},
	 { "StochasticProcess_evolve", _wrap_StochasticProcess_evolve, METH_VARARGS, "StochasticProcess_evolve(StochasticProcess self, Time t0, Array x0, Time dt, Array dw) -> Array"},
	 { "delete_StochasticProcess", _wrap_delete_StochasticProcess, METH_O, "delete_StochasticProcess(StochasticProcess self)"},
	 { "StochasticProcess_swigregister", StochasticProcess_swigregister, METH_O, NULL},
	 { "StochasticProcessVector_iterator", _wrap_StochasticProcessVector_iterator, METH_O, "StochasticProcessVector_iterator(StochasticProcessVector self) -> SwigPyIterator"},
	 { "StochasticProcessVector___nonzero__", _wrap_StochasticProcessVector___nonzero__, METH_O, "StochasticProcessVector___nonzero__(StochasticProcessVector self) -> bool"},
	 { "StochasticProcessVector___bool__", _wrap_StochasticProcessVector___bool__, METH_O, "StochasticProcessVector___bool__(StochasticProcessVector self) -> bool"},
	 { "StochasticProcessVector___len__", _wrap_StochasticProcessVector___len__, METH_O, "StochasticProcessVector___len__(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::size_type"},
	 { "StochasticProcessVector___getslice__", _wrap_StochasticProcessVector___getslice__, METH_VARARGS, "StochasticProcessVector___getslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j) -> StochasticProcessVector"},
	 { "StochasticProcessVector___setslice__", _wrap_StochasticProcessVector___setslice__, METH_VARARGS, "\n"
		"StochasticProcessVector___setslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j)\n"
		"StochasticProcessVector___setslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j, StochasticProcessVector v)\n"
		""},
	 { "StochasticProcessVector___delslice__", _wrap_StochasticProcessVector___delslice__, METH_VARARGS, "StochasticProcessVector___delslice__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type j)"},
	 { "StochasticProcessVector___delitem__", _wrap_StochasticProcessVector___delitem__, METH_VARARGS, "\n"
		"StochasticProcessVector___delitem__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i)\n"
		"StochasticProcessVector___delitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "StochasticProcessVector___getitem__", _wrap_StochasticProcessVector___getitem__, METH_VARARGS, "\n"
		"StochasticProcessVector___getitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice) -> StochasticProcessVector\n"
		"StochasticProcessVector___getitem__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &\n"
		""},
	 { "StochasticProcessVector___setitem__", _wrap_StochasticProcessVector___setitem__, METH_VARARGS, "\n"
		"StochasticProcessVector___setitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice, StochasticProcessVector v)\n"
		"StochasticProcessVector___setitem__(StochasticProcessVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"StochasticProcessVector___setitem__(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)\n"
		""},
	 { "StochasticProcessVector_pop", _wrap_StochasticProcessVector_pop, METH_O, "StochasticProcessVector_pop(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type"},
	 { "StochasticProcessVector_append", _wrap_StochasticProcessVector_append, METH_VARARGS, "StochasticProcessVector_append(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)"},
	 { "StochasticProcessVector_empty", _wrap_StochasticProcessVector_empty, METH_O, "StochasticProcessVector_empty(StochasticProcessVector self) -> bool"},
	 { "StochasticProcessVector_size", _wrap_StochasticProcessVector_size, METH_O, "StochasticProcessVector_size(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::size_type"},
	 { "StochasticProcessVector_swap", _wrap_StochasticProcessVector_swap, METH_VARARGS, "StochasticProcessVector_swap(StochasticProcessVector self, StochasticProcessVector v)"},
	 { "StochasticProcessVector_begin", _wrap_StochasticProcessVector_begin, METH_O, "StochasticProcessVector_begin(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator"},
	 { "StochasticProcessVector_end", _wrap_StochasticProcessVector_end, METH_O, "StochasticProcessVector_end(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator"},
	 { "StochasticProcessVector_rbegin", _wrap_StochasticProcessVector_rbegin, METH_O, "StochasticProcessVector_rbegin(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator"},
	 { "StochasticProcessVector_rend", _wrap_StochasticProcessVector_rend, METH_O, "StochasticProcessVector_rend(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::reverse_iterator"},
	 { "StochasticProcessVector_clear", _wrap_StochasticProcessVector_clear, METH_O, "StochasticProcessVector_clear(StochasticProcessVector self)"},
	 { "StochasticProcessVector_get_allocator", _wrap_StochasticProcessVector_get_allocator, METH_O, "StochasticProcessVector_get_allocator(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::allocator_type"},
	 { "StochasticProcessVector_pop_back", _wrap_StochasticProcessVector_pop_back, METH_O, "StochasticProcessVector_pop_back(StochasticProcessVector self)"},
	 { "StochasticProcessVector_erase", _wrap_StochasticProcessVector_erase, METH_VARARGS, "\n"
		"StochasticProcessVector_erase(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator\n"
		"StochasticProcessVector_erase(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator first, std::vector< ext::shared_ptr< StochasticProcess > >::iterator last) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator\n"
		""},
	 { "new_StochasticProcessVector", _wrap_new_StochasticProcessVector, METH_VARARGS, "\n"
		"StochasticProcessVector()\n"
		"StochasticProcessVector(StochasticProcessVector other)\n"
		"StochasticProcessVector(std::vector< ext::shared_ptr< StochasticProcess > >::size_type size)\n"
		"new_StochasticProcessVector(std::vector< ext::shared_ptr< StochasticProcess > >::size_type size, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & value) -> StochasticProcessVector\n"
		""},
	 { "StochasticProcessVector_push_back", _wrap_StochasticProcessVector_push_back, METH_VARARGS, "StochasticProcessVector_push_back(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)"},
	 { "StochasticProcessVector_front", _wrap_StochasticProcessVector_front, METH_O, "StochasticProcessVector_front(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &"},
	 { "StochasticProcessVector_back", _wrap_StochasticProcessVector_back, METH_O, "StochasticProcessVector_back(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::value_type const &"},
	 { "StochasticProcessVector_assign", _wrap_StochasticProcessVector_assign, METH_VARARGS, "StochasticProcessVector_assign(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)"},
	 { "StochasticProcessVector_resize", _wrap_StochasticProcessVector_resize, METH_VARARGS, "\n"
		"StochasticProcessVector_resize(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type new_size)\n"
		"StochasticProcessVector_resize(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type new_size, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)\n"
		""},
	 { "StochasticProcessVector_insert", _wrap_StochasticProcessVector_insert, METH_VARARGS, "\n"
		"StochasticProcessVector_insert(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x) -> std::vector< ext::shared_ptr< StochasticProcess > >::iterator\n"
		"StochasticProcessVector_insert(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess > >::value_type const & x)\n"
		""},
	 { "StochasticProcessVector_reserve", _wrap_StochasticProcessVector_reserve, METH_VARARGS, "StochasticProcessVector_reserve(StochasticProcessVector self, std::vector< ext::shared_ptr< StochasticProcess > >::size_type n)"},
	 { "StochasticProcessVector_capacity", _wrap_StochasticProcessVector_capacity, METH_O, "StochasticProcessVector_capacity(StochasticProcessVector self) -> std::vector< ext::shared_ptr< StochasticProcess > >::size_type"},
	 { "delete_StochasticProcessVector", _wrap_delete_StochasticProcessVector, METH_O, "delete_StochasticProcessVector(StochasticProcessVector self)"},
	 { "StochasticProcessVector_swigregister", StochasticProcessVector_swigregister, METH_O, NULL},
	 { "StochasticProcessVector_swiginit", StochasticProcessVector_swiginit, METH_VARARGS, NULL},
	 { "StochasticProcess1D_x0", _wrap_StochasticProcess1D_x0, METH_O, "StochasticProcess1D_x0(StochasticProcess1D self) -> Real"},
	 { "StochasticProcess1D_drift", _wrap_StochasticProcess1D_drift, METH_VARARGS, "StochasticProcess1D_drift(StochasticProcess1D self, Time t, Real x) -> Real"},
	 { "StochasticProcess1D_diffusion", _wrap_StochasticProcess1D_diffusion, METH_VARARGS, "StochasticProcess1D_diffusion(StochasticProcess1D self, Time t, Real x) -> Real"},
	 { "StochasticProcess1D_expectation", _wrap_StochasticProcess1D_expectation, METH_VARARGS, "StochasticProcess1D_expectation(StochasticProcess1D self, Time t0, Real x0, Time dt) -> Real"},
	 { "StochasticProcess1D_stdDeviation", _wrap_StochasticProcess1D_stdDeviation, METH_VARARGS, "StochasticProcess1D_stdDeviation(StochasticProcess1D self, Time t0, Real x0, Time dt) -> Real"},
	 { "StochasticProcess1D_variance", _wrap_StochasticProcess1D_variance, METH_VARARGS, "StochasticProcess1D_variance(StochasticProcess1D self, Time t0, Real x0, Time dt) -> Real"},
	 { "StochasticProcess1D_evolve", _wrap_StochasticProcess1D_evolve, METH_VARARGS, "StochasticProcess1D_evolve(StochasticProcess1D self, Time t0, Real x0, Time dt, Real dw) -> Real"},
	 { "StochasticProcess1D_apply", _wrap_StochasticProcess1D_apply, METH_VARARGS, "StochasticProcess1D_apply(StochasticProcess1D self, Real x0, Real dx) -> Real"},
	 { "delete_StochasticProcess1D", _wrap_delete_StochasticProcess1D, METH_O, "delete_StochasticProcess1D(StochasticProcess1D self)"},
	 { "StochasticProcess1D_swigregister", StochasticProcess1D_swigregister, METH_O, NULL},
	 { "StochasticProcess1DVector_iterator", _wrap_StochasticProcess1DVector_iterator, METH_O, "StochasticProcess1DVector_iterator(StochasticProcess1DVector self) -> SwigPyIterator"},
	 { "StochasticProcess1DVector___nonzero__", _wrap_StochasticProcess1DVector___nonzero__, METH_O, "StochasticProcess1DVector___nonzero__(StochasticProcess1DVector self) -> bool"},
	 { "StochasticProcess1DVector___bool__", _wrap_StochasticProcess1DVector___bool__, METH_O, "StochasticProcess1DVector___bool__(StochasticProcess1DVector self) -> bool"},
	 { "StochasticProcess1DVector___len__", _wrap_StochasticProcess1DVector___len__, METH_O, "StochasticProcess1DVector___len__(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type"},
	 { "StochasticProcess1DVector___getslice__", _wrap_StochasticProcess1DVector___getslice__, METH_VARARGS, "StochasticProcess1DVector___getslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j) -> StochasticProcess1DVector"},
	 { "StochasticProcess1DVector___setslice__", _wrap_StochasticProcess1DVector___setslice__, METH_VARARGS, "\n"
		"StochasticProcess1DVector___setslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j)\n"
		"StochasticProcess1DVector___setslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j, StochasticProcess1DVector v)\n"
		""},
	 { "StochasticProcess1DVector___delslice__", _wrap_StochasticProcess1DVector___delslice__, METH_VARARGS, "StochasticProcess1DVector___delslice__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type j)"},
	 { "StochasticProcess1DVector___delitem__", _wrap_StochasticProcess1DVector___delitem__, METH_VARARGS, "\n"
		"StochasticProcess1DVector___delitem__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i)\n"
		"StochasticProcess1DVector___delitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "StochasticProcess1DVector___getitem__", _wrap_StochasticProcess1DVector___getitem__, METH_VARARGS, "\n"
		"StochasticProcess1DVector___getitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice) -> StochasticProcess1DVector\n"
		"StochasticProcess1DVector___getitem__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &\n"
		""},
	 { "StochasticProcess1DVector___setitem__", _wrap_StochasticProcess1DVector___setitem__, METH_VARARGS, "\n"
		"StochasticProcess1DVector___setitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice, StochasticProcess1DVector v)\n"
		"StochasticProcess1DVector___setitem__(StochasticProcess1DVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"StochasticProcess1DVector___setitem__(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::difference_type i, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)\n"
		""},
	 { "StochasticProcess1DVector_pop", _wrap_StochasticProcess1DVector_pop, METH_O, "StochasticProcess1DVector_pop(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type"},
	 { "StochasticProcess1DVector_append", _wrap_StochasticProcess1DVector_append, METH_VARARGS, "StochasticProcess1DVector_append(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)"},
	 { "StochasticProcess1DVector_empty", _wrap_StochasticProcess1DVector_empty, METH_O, "StochasticProcess1DVector_empty(StochasticProcess1DVector self) -> bool"},
	 { "StochasticProcess1DVector_size", _wrap_StochasticProcess1DVector_size, METH_O, "StochasticProcess1DVector_size(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type"},
	 { "StochasticProcess1DVector_swap", _wrap_StochasticProcess1DVector_swap, METH_VARARGS, "StochasticProcess1DVector_swap(StochasticProcess1DVector self, StochasticProcess1DVector v)"},
	 { "StochasticProcess1DVector_begin", _wrap_StochasticProcess1DVector_begin, METH_O, "StochasticProcess1DVector_begin(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator"},
	 { "StochasticProcess1DVector_end", _wrap_StochasticProcess1DVector_end, METH_O, "StochasticProcess1DVector_end(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator"},
	 { "StochasticProcess1DVector_rbegin", _wrap_StochasticProcess1DVector_rbegin, METH_O, "StochasticProcess1DVector_rbegin(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator"},
	 { "StochasticProcess1DVector_rend", _wrap_StochasticProcess1DVector_rend, METH_O, "StochasticProcess1DVector_rend(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::reverse_iterator"},
	 { "StochasticProcess1DVector_clear", _wrap_StochasticProcess1DVector_clear, METH_O, "StochasticProcess1DVector_clear(StochasticProcess1DVector self)"},
	 { "StochasticProcess1DVector_get_allocator", _wrap_StochasticProcess1DVector_get_allocator, METH_O, "StochasticProcess1DVector_get_allocator(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::allocator_type"},
	 { "StochasticProcess1DVector_pop_back", _wrap_StochasticProcess1DVector_pop_back, METH_O, "StochasticProcess1DVector_pop_back(StochasticProcess1DVector self)"},
	 { "StochasticProcess1DVector_erase", _wrap_StochasticProcess1DVector_erase, METH_VARARGS, "\n"
		"StochasticProcess1DVector_erase(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator\n"
		"StochasticProcess1DVector_erase(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator first, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator last) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator\n"
		""},
	 { "new_StochasticProcess1DVector", _wrap_new_StochasticProcess1DVector, METH_VARARGS, "\n"
		"StochasticProcess1DVector()\n"
		"StochasticProcess1DVector(StochasticProcess1DVector other)\n"
		"StochasticProcess1DVector(std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type size)\n"
		"new_StochasticProcess1DVector(std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type size, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & value) -> StochasticProcess1DVector\n"
		""},
	 { "StochasticProcess1DVector_push_back", _wrap_StochasticProcess1DVector_push_back, METH_VARARGS, "StochasticProcess1DVector_push_back(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)"},
	 { "StochasticProcess1DVector_front", _wrap_StochasticProcess1DVector_front, METH_O, "StochasticProcess1DVector_front(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &"},
	 { "StochasticProcess1DVector_back", _wrap_StochasticProcess1DVector_back, METH_O, "StochasticProcess1DVector_back(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const &"},
	 { "StochasticProcess1DVector_assign", _wrap_StochasticProcess1DVector_assign, METH_VARARGS, "StochasticProcess1DVector_assign(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)"},
	 { "StochasticProcess1DVector_resize", _wrap_StochasticProcess1DVector_resize, METH_VARARGS, "\n"
		"StochasticProcess1DVector_resize(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type new_size)\n"
		"StochasticProcess1DVector_resize(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type new_size, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)\n"
		""},
	 { "StochasticProcess1DVector_insert", _wrap_StochasticProcess1DVector_insert, METH_VARARGS, "\n"
		"StochasticProcess1DVector_insert(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator\n"
		"StochasticProcess1DVector_insert(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::iterator pos, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n, std::vector< ext::shared_ptr< StochasticProcess1D > >::value_type const & x)\n"
		""},
	 { "StochasticProcess1DVector_reserve", _wrap_StochasticProcess1DVector_reserve, METH_VARARGS, "StochasticProcess1DVector_reserve(StochasticProcess1DVector self, std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type n)"},
	 { "StochasticProcess1DVector_capacity", _wrap_StochasticProcess1DVector_capacity, METH_O, "StochasticProcess1DVector_capacity(StochasticProcess1DVector self) -> std::vector< ext::shared_ptr< StochasticProcess1D > >::size_type"},
	 { "delete_StochasticProcess1DVector", _wrap_delete_StochasticProcess1DVector, METH_O, "delete_StochasticProcess1DVector(StochasticProcess1DVector self)"},
	 { "StochasticProcess1DVector_swigregister", StochasticProcess1DVector_swigregister, METH_O, NULL},
	 { "StochasticProcess1DVector_swiginit", StochasticProcess1DVector_swiginit, METH_VARARGS, NULL},
	 { "new_GeneralizedBlackScholesProcess", _wrap_new_GeneralizedBlackScholesProcess, METH_VARARGS, "\n"
		"GeneralizedBlackScholesProcess(QuoteHandle s0, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS)\n"
		"new_GeneralizedBlackScholesProcess(QuoteHandle x0, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle blackVolTS, LocalVolTermStructureHandle localVolTS) -> GeneralizedBlackScholesProcess\n"
		""},
	 { "GeneralizedBlackScholesProcess_stateVariable", _wrap_GeneralizedBlackScholesProcess_stateVariable, METH_O, "GeneralizedBlackScholesProcess_stateVariable(GeneralizedBlackScholesProcess self) -> QuoteHandle"},
	 { "GeneralizedBlackScholesProcess_dividendYield", _wrap_GeneralizedBlackScholesProcess_dividendYield, METH_O, "GeneralizedBlackScholesProcess_dividendYield(GeneralizedBlackScholesProcess self) -> YieldTermStructureHandle"},
	 { "GeneralizedBlackScholesProcess_riskFreeRate", _wrap_GeneralizedBlackScholesProcess_riskFreeRate, METH_O, "GeneralizedBlackScholesProcess_riskFreeRate(GeneralizedBlackScholesProcess self) -> YieldTermStructureHandle"},
	 { "GeneralizedBlackScholesProcess_blackVolatility", _wrap_GeneralizedBlackScholesProcess_blackVolatility, METH_O, "GeneralizedBlackScholesProcess_blackVolatility(GeneralizedBlackScholesProcess self) -> BlackVolTermStructureHandle"},
	 { "GeneralizedBlackScholesProcess_localVolatility", _wrap_GeneralizedBlackScholesProcess_localVolatility, METH_O, "GeneralizedBlackScholesProcess_localVolatility(GeneralizedBlackScholesProcess self) -> LocalVolTermStructureHandle"},
	 { "delete_GeneralizedBlackScholesProcess", _wrap_delete_GeneralizedBlackScholesProcess, METH_O, "delete_GeneralizedBlackScholesProcess(GeneralizedBlackScholesProcess self)"},
	 { "GeneralizedBlackScholesProcess_swigregister", GeneralizedBlackScholesProcess_swigregister, METH_O, NULL},
	 { "GeneralizedBlackScholesProcess_swiginit", GeneralizedBlackScholesProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BlackScholesProcess", _wrap_new_BlackScholesProcess, METH_VARARGS, "new_BlackScholesProcess(QuoteHandle s0, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> BlackScholesProcess"},
	 { "delete_BlackScholesProcess", _wrap_delete_BlackScholesProcess, METH_O, "delete_BlackScholesProcess(BlackScholesProcess self)"},
	 { "BlackScholesProcess_swigregister", BlackScholesProcess_swigregister, METH_O, NULL},
	 { "BlackScholesProcess_swiginit", BlackScholesProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BlackScholesMertonProcess", _wrap_new_BlackScholesMertonProcess, METH_VARARGS, "new_BlackScholesMertonProcess(QuoteHandle s0, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> BlackScholesMertonProcess"},
	 { "delete_BlackScholesMertonProcess", _wrap_delete_BlackScholesMertonProcess, METH_O, "delete_BlackScholesMertonProcess(BlackScholesMertonProcess self)"},
	 { "BlackScholesMertonProcess_swigregister", BlackScholesMertonProcess_swigregister, METH_O, NULL},
	 { "BlackScholesMertonProcess_swiginit", BlackScholesMertonProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BlackProcess", _wrap_new_BlackProcess, METH_VARARGS, "new_BlackProcess(QuoteHandle s0, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS) -> BlackProcess"},
	 { "delete_BlackProcess", _wrap_delete_BlackProcess, METH_O, "delete_BlackProcess(BlackProcess self)"},
	 { "BlackProcess_swigregister", BlackProcess_swigregister, METH_O, NULL},
	 { "BlackProcess_swiginit", BlackProcess_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKohlagenProcess", _wrap_new_GarmanKohlagenProcess, METH_VARARGS, "new_GarmanKohlagenProcess(QuoteHandle s0, YieldTermStructureHandle foreignRiskFreeTS, YieldTermStructureHandle domesticRiskFreeTS, BlackVolTermStructureHandle volTS) -> GarmanKohlagenProcess"},
	 { "delete_GarmanKohlagenProcess", _wrap_delete_GarmanKohlagenProcess, METH_O, "delete_GarmanKohlagenProcess(GarmanKohlagenProcess self)"},
	 { "GarmanKohlagenProcess_swigregister", GarmanKohlagenProcess_swigregister, METH_O, NULL},
	 { "GarmanKohlagenProcess_swiginit", GarmanKohlagenProcess_swiginit, METH_VARARGS, NULL},
	 { "new_Merton76Process", _wrap_new_Merton76Process, METH_VARARGS, "new_Merton76Process(QuoteHandle stateVariable, YieldTermStructureHandle dividendTS, YieldTermStructureHandle riskFreeTS, BlackVolTermStructureHandle volTS, QuoteHandle jumpIntensity, QuoteHandle meanLogJump, QuoteHandle jumpVolatility) -> Merton76Process"},
	 { "delete_Merton76Process", _wrap_delete_Merton76Process, METH_O, "delete_Merton76Process(Merton76Process self)"},
	 { "Merton76Process_swigregister", Merton76Process_swigregister, METH_O, NULL},
	 { "Merton76Process_swiginit", Merton76Process_swiginit, METH_VARARGS, NULL},
	 { "new_StochasticProcessArray", _wrap_new_StochasticProcessArray, METH_VARARGS, "new_StochasticProcessArray(StochasticProcess1DVector array, Matrix correlation) -> StochasticProcessArray"},
	 { "delete_StochasticProcessArray", _wrap_delete_StochasticProcessArray, METH_O, "delete_StochasticProcessArray(StochasticProcessArray self)"},
	 { "StochasticProcessArray_swigregister", StochasticProcessArray_swigregister, METH_O, NULL},
	 { "StochasticProcessArray_swiginit", StochasticProcessArray_swiginit, METH_VARARGS, NULL},
	 { "new_GeometricBrownianMotionProcess", _wrap_new_GeometricBrownianMotionProcess, METH_VARARGS, "new_GeometricBrownianMotionProcess(Real initialValue, Real mu, Real sigma) -> GeometricBrownianMotionProcess"},
	 { "delete_GeometricBrownianMotionProcess", _wrap_delete_GeometricBrownianMotionProcess, METH_O, "delete_GeometricBrownianMotionProcess(GeometricBrownianMotionProcess self)"},
	 { "GeometricBrownianMotionProcess_swigregister", GeometricBrownianMotionProcess_swigregister, METH_O, NULL},
	 { "GeometricBrownianMotionProcess_swiginit", GeometricBrownianMotionProcess_swiginit, METH_VARARGS, NULL},
	 { "new_VarianceGammaProcess", _wrap_new_VarianceGammaProcess, METH_VARARGS, "new_VarianceGammaProcess(QuoteHandle s0, YieldTermStructureHandle dividendYield, YieldTermStructureHandle riskFreeRate, Real sigma, Real nu, Real theta) -> VarianceGammaProcess"},
	 { "delete_VarianceGammaProcess", _wrap_delete_VarianceGammaProcess, METH_O, "delete_VarianceGammaProcess(VarianceGammaProcess self)"},
	 { "VarianceGammaProcess_swigregister", VarianceGammaProcess_swigregister, METH_O, NULL},
	 { "VarianceGammaProcess_swiginit", VarianceGammaProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HestonProcess", _wrap_new_HestonProcess, METH_VARARGS, "HestonProcess(YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, QuoteHandle s0, Real v0, Real kappa, Real theta, Real sigma, Real rho, HestonProcess::Discretization d=QuadraticExponentialMartingale)"},
	 { "HestonProcess_s0", _wrap_HestonProcess_s0, METH_O, "HestonProcess_s0(HestonProcess self) -> QuoteHandle"},
	 { "HestonProcess_dividendYield", _wrap_HestonProcess_dividendYield, METH_O, "HestonProcess_dividendYield(HestonProcess self) -> YieldTermStructureHandle"},
	 { "HestonProcess_riskFreeRate", _wrap_HestonProcess_riskFreeRate, METH_O, "HestonProcess_riskFreeRate(HestonProcess self) -> YieldTermStructureHandle"},
	 { "delete_HestonProcess", _wrap_delete_HestonProcess, METH_O, "delete_HestonProcess(HestonProcess self)"},
	 { "HestonProcess_swigregister", HestonProcess_swigregister, METH_O, NULL},
	 { "HestonProcess_swiginit", HestonProcess_swiginit, METH_VARARGS, NULL},
	 { "new_BatesProcess", _wrap_new_BatesProcess, METH_VARARGS, "new_BatesProcess(YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, QuoteHandle s0, Real v0, Real kappa, Real theta, Real sigma, Real rho, Real lambda_parameter, Real nu, Real delta) -> BatesProcess"},
	 { "delete_BatesProcess", _wrap_delete_BatesProcess, METH_O, "delete_BatesProcess(BatesProcess self)"},
	 { "BatesProcess_swigregister", BatesProcess_swigregister, METH_O, NULL},
	 { "BatesProcess_swiginit", BatesProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HullWhiteProcess", _wrap_new_HullWhiteProcess, METH_VARARGS, "new_HullWhiteProcess(YieldTermStructureHandle riskFreeTS, Real a, Real sigma) -> HullWhiteProcess"},
	 { "delete_HullWhiteProcess", _wrap_delete_HullWhiteProcess, METH_O, "delete_HullWhiteProcess(HullWhiteProcess self)"},
	 { "HullWhiteProcess_swigregister", HullWhiteProcess_swigregister, METH_O, NULL},
	 { "HullWhiteProcess_swiginit", HullWhiteProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HullWhiteForwardProcess", _wrap_new_HullWhiteForwardProcess, METH_VARARGS, "new_HullWhiteForwardProcess(YieldTermStructureHandle riskFreeTS, Real a, Real sigma) -> HullWhiteForwardProcess"},
	 { "HullWhiteForwardProcess_alpha", _wrap_HullWhiteForwardProcess_alpha, METH_VARARGS, "HullWhiteForwardProcess_alpha(HullWhiteForwardProcess self, Time t) -> Real"},
	 { "HullWhiteForwardProcess_M_T", _wrap_HullWhiteForwardProcess_M_T, METH_VARARGS, "HullWhiteForwardProcess_M_T(HullWhiteForwardProcess self, Real s, Real t, Real T) -> Real"},
	 { "HullWhiteForwardProcess_B", _wrap_HullWhiteForwardProcess_B, METH_VARARGS, "HullWhiteForwardProcess_B(HullWhiteForwardProcess self, Time t, Time T) -> Real"},
	 { "HullWhiteForwardProcess_setForwardMeasureTime", _wrap_HullWhiteForwardProcess_setForwardMeasureTime, METH_VARARGS, "HullWhiteForwardProcess_setForwardMeasureTime(HullWhiteForwardProcess self, Time t)"},
	 { "delete_HullWhiteForwardProcess", _wrap_delete_HullWhiteForwardProcess, METH_O, "delete_HullWhiteForwardProcess(HullWhiteForwardProcess self)"},
	 { "HullWhiteForwardProcess_swigregister", HullWhiteForwardProcess_swigregister, METH_O, NULL},
	 { "HullWhiteForwardProcess_swiginit", HullWhiteForwardProcess_swiginit, METH_VARARGS, NULL},
	 { "new_G2Process", _wrap_new_G2Process, METH_VARARGS, "new_G2Process(Real a, Real sigma, Real b, Real eta, Real rho) -> G2Process"},
	 { "delete_G2Process", _wrap_delete_G2Process, METH_O, "delete_G2Process(G2Process self)"},
	 { "G2Process_swigregister", G2Process_swigregister, METH_O, NULL},
	 { "G2Process_swiginit", G2Process_swiginit, METH_VARARGS, NULL},
	 { "new_G2ForwardProcess", _wrap_new_G2ForwardProcess, METH_VARARGS, "new_G2ForwardProcess(Real a, Real sigma, Real b, Real eta, Real rho) -> G2ForwardProcess"},
	 { "G2ForwardProcess_setForwardMeasureTime", _wrap_G2ForwardProcess_setForwardMeasureTime, METH_VARARGS, "G2ForwardProcess_setForwardMeasureTime(G2ForwardProcess self, Time t)"},
	 { "delete_G2ForwardProcess", _wrap_delete_G2ForwardProcess, METH_O, "delete_G2ForwardProcess(G2ForwardProcess self)"},
	 { "G2ForwardProcess_swigregister", G2ForwardProcess_swigregister, METH_O, NULL},
	 { "G2ForwardProcess_swiginit", G2ForwardProcess_swiginit, METH_VARARGS, NULL},
	 { "new_GsrProcess", _wrap_new_GsrProcess, METH_VARARGS, "GsrProcess(Array times, Array vols, Array reversions, Real const T=60.0)"},
	 { "GsrProcess_sigma", _wrap_GsrProcess_sigma, METH_VARARGS, "GsrProcess_sigma(GsrProcess self, Time t) -> Real"},
	 { "GsrProcess_reversion", _wrap_GsrProcess_reversion, METH_VARARGS, "GsrProcess_reversion(GsrProcess self, Time t) -> Real"},
	 { "GsrProcess_y", _wrap_GsrProcess_y, METH_VARARGS, "GsrProcess_y(GsrProcess self, Time t) -> Real"},
	 { "GsrProcess_G", _wrap_GsrProcess_G, METH_VARARGS, "GsrProcess_G(GsrProcess self, Time t, Time T, Real x) -> Real"},
	 { "GsrProcess_setForwardMeasureTime", _wrap_GsrProcess_setForwardMeasureTime, METH_VARARGS, "GsrProcess_setForwardMeasureTime(GsrProcess self, Time t)"},
	 { "delete_GsrProcess", _wrap_delete_GsrProcess, METH_O, "delete_GsrProcess(GsrProcess self)"},
	 { "GsrProcess_swigregister", GsrProcess_swigregister, METH_O, NULL},
	 { "GsrProcess_swiginit", GsrProcess_swiginit, METH_VARARGS, NULL},
	 { "as_gsr_process", _wrap_as_gsr_process, METH_O, "as_gsr_process(ext::shared_ptr< StochasticProcess > const & proc) -> ext::shared_ptr< GsrProcess > const"},
	 { "new_OrnsteinUhlenbeckProcess", _wrap_new_OrnsteinUhlenbeckProcess, METH_VARARGS, "OrnsteinUhlenbeckProcess(Real speed, Volatility vol, Real x0=0.0, Real level=0.0)"},
	 { "OrnsteinUhlenbeckProcess_speed", _wrap_OrnsteinUhlenbeckProcess_speed, METH_O, "OrnsteinUhlenbeckProcess_speed(OrnsteinUhlenbeckProcess self) -> Real"},
	 { "OrnsteinUhlenbeckProcess_volatility", _wrap_OrnsteinUhlenbeckProcess_volatility, METH_O, "OrnsteinUhlenbeckProcess_volatility(OrnsteinUhlenbeckProcess self) -> Real"},
	 { "OrnsteinUhlenbeckProcess_level", _wrap_OrnsteinUhlenbeckProcess_level, METH_O, "OrnsteinUhlenbeckProcess_level(OrnsteinUhlenbeckProcess self) -> Real"},
	 { "delete_OrnsteinUhlenbeckProcess", _wrap_delete_OrnsteinUhlenbeckProcess, METH_O, "delete_OrnsteinUhlenbeckProcess(OrnsteinUhlenbeckProcess self)"},
	 { "OrnsteinUhlenbeckProcess_swigregister", OrnsteinUhlenbeckProcess_swigregister, METH_O, NULL},
	 { "OrnsteinUhlenbeckProcess_swiginit", OrnsteinUhlenbeckProcess_swiginit, METH_VARARGS, NULL},
	 { "new_ExtendedOrnsteinUhlenbeckProcess", _wrap_new_ExtendedOrnsteinUhlenbeckProcess, METH_VARARGS, "\n"
		"ExtendedOrnsteinUhlenbeckProcess(Real speed, Volatility sigma, Real x0, ext::function< Real (Real) > const & b, ExtendedOrnsteinUhlenbeckProcess::Discretization discretization=MidPoint, Real intEps=1e-4)\n"
		"ExtendedOrnsteinUhlenbeckProcess(Real speed, Volatility sigma, Real x0, PyObject * function, Real intEps=1e-4)\n"
		""},
	 { "delete_ExtendedOrnsteinUhlenbeckProcess", _wrap_delete_ExtendedOrnsteinUhlenbeckProcess, METH_O, "delete_ExtendedOrnsteinUhlenbeckProcess(ExtendedOrnsteinUhlenbeckProcess self)"},
	 { "ExtendedOrnsteinUhlenbeckProcess_swigregister", ExtendedOrnsteinUhlenbeckProcess_swigregister, METH_O, NULL},
	 { "ExtendedOrnsteinUhlenbeckProcess_swiginit", ExtendedOrnsteinUhlenbeckProcess_swiginit, METH_VARARGS, NULL},
	 { "new_ExtOUWithJumpsProcess", _wrap_new_ExtOUWithJumpsProcess, METH_VARARGS, "new_ExtOUWithJumpsProcess(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const & process, Real Y0, Real beta, Real jumpIntensity, Real eta) -> ExtOUWithJumpsProcess"},
	 { "delete_ExtOUWithJumpsProcess", _wrap_delete_ExtOUWithJumpsProcess, METH_O, "delete_ExtOUWithJumpsProcess(ExtOUWithJumpsProcess self)"},
	 { "ExtOUWithJumpsProcess_swigregister", ExtOUWithJumpsProcess_swigregister, METH_O, NULL},
	 { "ExtOUWithJumpsProcess_swiginit", ExtOUWithJumpsProcess_swiginit, METH_VARARGS, NULL},
	 { "new_KlugeExtOUProcess", _wrap_new_KlugeExtOUProcess, METH_VARARGS, "new_KlugeExtOUProcess(Real rho, ext::shared_ptr< ExtOUWithJumpsProcess > const & kluge, ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > const & extOU) -> KlugeExtOUProcess"},
	 { "delete_KlugeExtOUProcess", _wrap_delete_KlugeExtOUProcess, METH_O, "delete_KlugeExtOUProcess(KlugeExtOUProcess self)"},
	 { "KlugeExtOUProcess_swigregister", KlugeExtOUProcess_swigregister, METH_O, NULL},
	 { "KlugeExtOUProcess_swiginit", KlugeExtOUProcess_swiginit, METH_VARARGS, NULL},
	 { "new_GJRGARCHProcess", _wrap_new_GJRGARCHProcess, METH_VARARGS, "GJRGARCHProcess(YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, QuoteHandle s0, Real v0, Real omega, Real alpha, Real beta, Real gamma, Real lambda_parameter, Real daysPerYear=252.0, GJRGARCHProcess::Discretization d=FullTruncation)"},
	 { "GJRGARCHProcess_s0", _wrap_GJRGARCHProcess_s0, METH_O, "GJRGARCHProcess_s0(GJRGARCHProcess self) -> QuoteHandle"},
	 { "GJRGARCHProcess_dividendYield", _wrap_GJRGARCHProcess_dividendYield, METH_O, "GJRGARCHProcess_dividendYield(GJRGARCHProcess self) -> YieldTermStructureHandle"},
	 { "GJRGARCHProcess_riskFreeRate", _wrap_GJRGARCHProcess_riskFreeRate, METH_O, "GJRGARCHProcess_riskFreeRate(GJRGARCHProcess self) -> YieldTermStructureHandle"},
	 { "delete_GJRGARCHProcess", _wrap_delete_GJRGARCHProcess, METH_O, "delete_GJRGARCHProcess(GJRGARCHProcess self)"},
	 { "GJRGARCHProcess_swigregister", GJRGARCHProcess_swigregister, METH_O, NULL},
	 { "GJRGARCHProcess_swiginit", GJRGARCHProcess_swiginit, METH_VARARGS, NULL},
	 { "LazyObject_recalculate", _wrap_LazyObject_recalculate, METH_O, "LazyObject_recalculate(LazyObject self)"},
	 { "LazyObject_freeze", _wrap_LazyObject_freeze, METH_O, "LazyObject_freeze(LazyObject self)"},
	 { "LazyObject_unfreeze", _wrap_LazyObject_unfreeze, METH_O, "LazyObject_unfreeze(LazyObject self)"},
	 { "LazyObject_forwardFirstNotificationOnly", _wrap_LazyObject_forwardFirstNotificationOnly, METH_NOARGS, "LazyObject_forwardFirstNotificationOnly()"},
	 { "LazyObject_alwaysForwardNotifications", _wrap_LazyObject_alwaysForwardNotifications, METH_NOARGS, "LazyObject_alwaysForwardNotifications()"},
	 { "LazyObject_forwardsAllNotifications", _wrap_LazyObject_forwardsAllNotifications, METH_NOARGS, "LazyObject_forwardsAllNotifications() -> bool"},
	 { "delete_LazyObject", _wrap_delete_LazyObject, METH_O, "delete_LazyObject(LazyObject self)"},
	 { "LazyObject_swigregister", LazyObject_swigregister, METH_O, NULL},
	 { "delete_PricingEngine", _wrap_delete_PricingEngine, METH_O, "delete_PricingEngine(PricingEngine self)"},
	 { "PricingEngine_swigregister", PricingEngine_swigregister, METH_O, NULL},
	 { "Instrument_NPV", _wrap_Instrument_NPV, METH_O, "Instrument_NPV(Instrument self) -> Real"},
	 { "Instrument_errorEstimate", _wrap_Instrument_errorEstimate, METH_O, "Instrument_errorEstimate(Instrument self) -> Real"},
	 { "Instrument_isExpired", _wrap_Instrument_isExpired, METH_O, "Instrument_isExpired(Instrument self) -> bool"},
	 { "Instrument_setPricingEngine", _wrap_Instrument_setPricingEngine, METH_VARARGS, "Instrument_setPricingEngine(Instrument self, ext::shared_ptr< PricingEngine > const & arg2)"},
	 { "delete_Instrument", _wrap_delete_Instrument, METH_O, "delete_Instrument(Instrument self)"},
	 { "Instrument_swigregister", Instrument_swigregister, METH_O, NULL},
	 { "InstrumentVector_iterator", _wrap_InstrumentVector_iterator, METH_O, "InstrumentVector_iterator(InstrumentVector self) -> SwigPyIterator"},
	 { "InstrumentVector___nonzero__", _wrap_InstrumentVector___nonzero__, METH_O, "InstrumentVector___nonzero__(InstrumentVector self) -> bool"},
	 { "InstrumentVector___bool__", _wrap_InstrumentVector___bool__, METH_O, "InstrumentVector___bool__(InstrumentVector self) -> bool"},
	 { "InstrumentVector___len__", _wrap_InstrumentVector___len__, METH_O, "InstrumentVector___len__(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::size_type"},
	 { "InstrumentVector___getslice__", _wrap_InstrumentVector___getslice__, METH_VARARGS, "InstrumentVector___getslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j) -> InstrumentVector"},
	 { "InstrumentVector___setslice__", _wrap_InstrumentVector___setslice__, METH_VARARGS, "\n"
		"InstrumentVector___setslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j)\n"
		"InstrumentVector___setslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j, InstrumentVector v)\n"
		""},
	 { "InstrumentVector___delslice__", _wrap_InstrumentVector___delslice__, METH_VARARGS, "InstrumentVector___delslice__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::difference_type j)"},
	 { "InstrumentVector___delitem__", _wrap_InstrumentVector___delitem__, METH_VARARGS, "\n"
		"InstrumentVector___delitem__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i)\n"
		"InstrumentVector___delitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "InstrumentVector___getitem__", _wrap_InstrumentVector___getitem__, METH_VARARGS, "\n"
		"InstrumentVector___getitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice) -> InstrumentVector\n"
		"InstrumentVector___getitem__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i) -> std::vector< ext::shared_ptr< Instrument > >::value_type const &\n"
		""},
	 { "InstrumentVector___setitem__", _wrap_InstrumentVector___setitem__, METH_VARARGS, "\n"
		"InstrumentVector___setitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice, InstrumentVector v)\n"
		"InstrumentVector___setitem__(InstrumentVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"InstrumentVector___setitem__(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::difference_type i, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)\n"
		""},
	 { "InstrumentVector_pop", _wrap_InstrumentVector_pop, METH_O, "InstrumentVector_pop(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::value_type"},
	 { "InstrumentVector_append", _wrap_InstrumentVector_append, METH_VARARGS, "InstrumentVector_append(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)"},
	 { "InstrumentVector_empty", _wrap_InstrumentVector_empty, METH_O, "InstrumentVector_empty(InstrumentVector self) -> bool"},
	 { "InstrumentVector_size", _wrap_InstrumentVector_size, METH_O, "InstrumentVector_size(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::size_type"},
	 { "InstrumentVector_swap", _wrap_InstrumentVector_swap, METH_VARARGS, "InstrumentVector_swap(InstrumentVector self, InstrumentVector v)"},
	 { "InstrumentVector_begin", _wrap_InstrumentVector_begin, METH_O, "InstrumentVector_begin(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::iterator"},
	 { "InstrumentVector_end", _wrap_InstrumentVector_end, METH_O, "InstrumentVector_end(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::iterator"},
	 { "InstrumentVector_rbegin", _wrap_InstrumentVector_rbegin, METH_O, "InstrumentVector_rbegin(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::reverse_iterator"},
	 { "InstrumentVector_rend", _wrap_InstrumentVector_rend, METH_O, "InstrumentVector_rend(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::reverse_iterator"},
	 { "InstrumentVector_clear", _wrap_InstrumentVector_clear, METH_O, "InstrumentVector_clear(InstrumentVector self)"},
	 { "InstrumentVector_get_allocator", _wrap_InstrumentVector_get_allocator, METH_O, "InstrumentVector_get_allocator(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::allocator_type"},
	 { "InstrumentVector_pop_back", _wrap_InstrumentVector_pop_back, METH_O, "InstrumentVector_pop_back(InstrumentVector self)"},
	 { "InstrumentVector_erase", _wrap_InstrumentVector_erase, METH_VARARGS, "\n"
		"InstrumentVector_erase(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator pos) -> std::vector< ext::shared_ptr< Instrument > >::iterator\n"
		"InstrumentVector_erase(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator first, std::vector< ext::shared_ptr< Instrument > >::iterator last) -> std::vector< ext::shared_ptr< Instrument > >::iterator\n"
		""},
	 { "new_InstrumentVector", _wrap_new_InstrumentVector, METH_VARARGS, "\n"
		"InstrumentVector()\n"
		"InstrumentVector(InstrumentVector other)\n"
		"InstrumentVector(std::vector< ext::shared_ptr< Instrument > >::size_type size)\n"
		"new_InstrumentVector(std::vector< ext::shared_ptr< Instrument > >::size_type size, std::vector< ext::shared_ptr< Instrument > >::value_type const & value) -> InstrumentVector\n"
		""},
	 { "InstrumentVector_push_back", _wrap_InstrumentVector_push_back, METH_VARARGS, "InstrumentVector_push_back(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)"},
	 { "InstrumentVector_front", _wrap_InstrumentVector_front, METH_O, "InstrumentVector_front(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::value_type const &"},
	 { "InstrumentVector_back", _wrap_InstrumentVector_back, METH_O, "InstrumentVector_back(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::value_type const &"},
	 { "InstrumentVector_assign", _wrap_InstrumentVector_assign, METH_VARARGS, "InstrumentVector_assign(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type n, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)"},
	 { "InstrumentVector_resize", _wrap_InstrumentVector_resize, METH_VARARGS, "\n"
		"InstrumentVector_resize(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type new_size)\n"
		"InstrumentVector_resize(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type new_size, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)\n"
		""},
	 { "InstrumentVector_insert", _wrap_InstrumentVector_insert, METH_VARARGS, "\n"
		"InstrumentVector_insert(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator pos, std::vector< ext::shared_ptr< Instrument > >::value_type const & x) -> std::vector< ext::shared_ptr< Instrument > >::iterator\n"
		"InstrumentVector_insert(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::iterator pos, std::vector< ext::shared_ptr< Instrument > >::size_type n, std::vector< ext::shared_ptr< Instrument > >::value_type const & x)\n"
		""},
	 { "InstrumentVector_reserve", _wrap_InstrumentVector_reserve, METH_VARARGS, "InstrumentVector_reserve(InstrumentVector self, std::vector< ext::shared_ptr< Instrument > >::size_type n)"},
	 { "InstrumentVector_capacity", _wrap_InstrumentVector_capacity, METH_O, "InstrumentVector_capacity(InstrumentVector self) -> std::vector< ext::shared_ptr< Instrument > >::size_type"},
	 { "delete_InstrumentVector", _wrap_delete_InstrumentVector, METH_O, "delete_InstrumentVector(InstrumentVector self)"},
	 { "InstrumentVector_swigregister", InstrumentVector_swigregister, METH_O, NULL},
	 { "InstrumentVector_swiginit", InstrumentVector_swiginit, METH_VARARGS, NULL},
	 { "new_Stock", _wrap_new_Stock, METH_O, "new_Stock(QuoteHandle quote) -> Stock"},
	 { "delete_Stock", _wrap_delete_Stock, METH_O, "delete_Stock(Stock self)"},
	 { "Stock_swigregister", Stock_swigregister, METH_O, NULL},
	 { "Stock_swiginit", Stock_swiginit, METH_VARARGS, NULL},
	 { "new_CompositeInstrument", _wrap_new_CompositeInstrument, METH_NOARGS, "new_CompositeInstrument() -> CompositeInstrument"},
	 { "CompositeInstrument_add", _wrap_CompositeInstrument_add, METH_VARARGS, "CompositeInstrument_add(CompositeInstrument self, ext::shared_ptr< Instrument > const & instrument, Real multiplier=1.0)"},
	 { "CompositeInstrument_subtract", _wrap_CompositeInstrument_subtract, METH_VARARGS, "CompositeInstrument_subtract(CompositeInstrument self, ext::shared_ptr< Instrument > const & instrument, Real multiplier=1.0)"},
	 { "delete_CompositeInstrument", _wrap_delete_CompositeInstrument, METH_O, "delete_CompositeInstrument(CompositeInstrument self)"},
	 { "CompositeInstrument_swigregister", CompositeInstrument_swigregister, METH_O, NULL},
	 { "CompositeInstrument_swiginit", CompositeInstrument_swiginit, METH_VARARGS, NULL},
	 { "CalibrationHelper_calibrationError", _wrap_CalibrationHelper_calibrationError, METH_O, "CalibrationHelper_calibrationError(CalibrationHelper self) -> Real"},
	 { "delete_CalibrationHelper", _wrap_delete_CalibrationHelper, METH_O, "delete_CalibrationHelper(CalibrationHelper self)"},
	 { "CalibrationHelper_swigregister", CalibrationHelper_swigregister, METH_O, NULL},
	 { "CalibrationHelperVector_iterator", _wrap_CalibrationHelperVector_iterator, METH_O, "CalibrationHelperVector_iterator(CalibrationHelperVector self) -> SwigPyIterator"},
	 { "CalibrationHelperVector___nonzero__", _wrap_CalibrationHelperVector___nonzero__, METH_O, "CalibrationHelperVector___nonzero__(CalibrationHelperVector self) -> bool"},
	 { "CalibrationHelperVector___bool__", _wrap_CalibrationHelperVector___bool__, METH_O, "CalibrationHelperVector___bool__(CalibrationHelperVector self) -> bool"},
	 { "CalibrationHelperVector___len__", _wrap_CalibrationHelperVector___len__, METH_O, "CalibrationHelperVector___len__(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::size_type"},
	 { "CalibrationHelperVector___getslice__", _wrap_CalibrationHelperVector___getslice__, METH_VARARGS, "CalibrationHelperVector___getslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j) -> CalibrationHelperVector"},
	 { "CalibrationHelperVector___setslice__", _wrap_CalibrationHelperVector___setslice__, METH_VARARGS, "\n"
		"CalibrationHelperVector___setslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j)\n"
		"CalibrationHelperVector___setslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j, CalibrationHelperVector v)\n"
		""},
	 { "CalibrationHelperVector___delslice__", _wrap_CalibrationHelperVector___delslice__, METH_VARARGS, "CalibrationHelperVector___delslice__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type j)"},
	 { "CalibrationHelperVector___delitem__", _wrap_CalibrationHelperVector___delitem__, METH_VARARGS, "\n"
		"CalibrationHelperVector___delitem__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i)\n"
		"CalibrationHelperVector___delitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "CalibrationHelperVector___getitem__", _wrap_CalibrationHelperVector___getitem__, METH_VARARGS, "\n"
		"CalibrationHelperVector___getitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice) -> CalibrationHelperVector\n"
		"CalibrationHelperVector___getitem__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &\n"
		""},
	 { "CalibrationHelperVector___setitem__", _wrap_CalibrationHelperVector___setitem__, METH_VARARGS, "\n"
		"CalibrationHelperVector___setitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice, CalibrationHelperVector v)\n"
		"CalibrationHelperVector___setitem__(CalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"CalibrationHelperVector___setitem__(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)\n"
		""},
	 { "CalibrationHelperVector_pop", _wrap_CalibrationHelperVector_pop, METH_O, "CalibrationHelperVector_pop(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type"},
	 { "CalibrationHelperVector_append", _wrap_CalibrationHelperVector_append, METH_VARARGS, "CalibrationHelperVector_append(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)"},
	 { "CalibrationHelperVector_empty", _wrap_CalibrationHelperVector_empty, METH_O, "CalibrationHelperVector_empty(CalibrationHelperVector self) -> bool"},
	 { "CalibrationHelperVector_size", _wrap_CalibrationHelperVector_size, METH_O, "CalibrationHelperVector_size(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::size_type"},
	 { "CalibrationHelperVector_swap", _wrap_CalibrationHelperVector_swap, METH_VARARGS, "CalibrationHelperVector_swap(CalibrationHelperVector self, CalibrationHelperVector v)"},
	 { "CalibrationHelperVector_begin", _wrap_CalibrationHelperVector_begin, METH_O, "CalibrationHelperVector_begin(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator"},
	 { "CalibrationHelperVector_end", _wrap_CalibrationHelperVector_end, METH_O, "CalibrationHelperVector_end(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator"},
	 { "CalibrationHelperVector_rbegin", _wrap_CalibrationHelperVector_rbegin, METH_O, "CalibrationHelperVector_rbegin(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator"},
	 { "CalibrationHelperVector_rend", _wrap_CalibrationHelperVector_rend, METH_O, "CalibrationHelperVector_rend(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::reverse_iterator"},
	 { "CalibrationHelperVector_clear", _wrap_CalibrationHelperVector_clear, METH_O, "CalibrationHelperVector_clear(CalibrationHelperVector self)"},
	 { "CalibrationHelperVector_get_allocator", _wrap_CalibrationHelperVector_get_allocator, METH_O, "CalibrationHelperVector_get_allocator(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::allocator_type"},
	 { "CalibrationHelperVector_pop_back", _wrap_CalibrationHelperVector_pop_back, METH_O, "CalibrationHelperVector_pop_back(CalibrationHelperVector self)"},
	 { "CalibrationHelperVector_erase", _wrap_CalibrationHelperVector_erase, METH_VARARGS, "\n"
		"CalibrationHelperVector_erase(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator\n"
		"CalibrationHelperVector_erase(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator first, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator last) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator\n"
		""},
	 { "new_CalibrationHelperVector", _wrap_new_CalibrationHelperVector, METH_VARARGS, "\n"
		"CalibrationHelperVector()\n"
		"CalibrationHelperVector(CalibrationHelperVector other)\n"
		"CalibrationHelperVector(std::vector< ext::shared_ptr< CalibrationHelper > >::size_type size)\n"
		"new_CalibrationHelperVector(std::vector< ext::shared_ptr< CalibrationHelper > >::size_type size, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & value) -> CalibrationHelperVector\n"
		""},
	 { "CalibrationHelperVector_push_back", _wrap_CalibrationHelperVector_push_back, METH_VARARGS, "CalibrationHelperVector_push_back(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)"},
	 { "CalibrationHelperVector_front", _wrap_CalibrationHelperVector_front, METH_O, "CalibrationHelperVector_front(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &"},
	 { "CalibrationHelperVector_back", _wrap_CalibrationHelperVector_back, METH_O, "CalibrationHelperVector_back(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const &"},
	 { "CalibrationHelperVector_assign", _wrap_CalibrationHelperVector_assign, METH_VARARGS, "CalibrationHelperVector_assign(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)"},
	 { "CalibrationHelperVector_resize", _wrap_CalibrationHelperVector_resize, METH_VARARGS, "\n"
		"CalibrationHelperVector_resize(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type new_size)\n"
		"CalibrationHelperVector_resize(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type new_size, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)\n"
		""},
	 { "CalibrationHelperVector_insert", _wrap_CalibrationHelperVector_insert, METH_VARARGS, "\n"
		"CalibrationHelperVector_insert(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< CalibrationHelper > >::iterator\n"
		"CalibrationHelperVector_insert(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< CalibrationHelper > >::value_type const & x)\n"
		""},
	 { "CalibrationHelperVector_reserve", _wrap_CalibrationHelperVector_reserve, METH_VARARGS, "CalibrationHelperVector_reserve(CalibrationHelperVector self, std::vector< ext::shared_ptr< CalibrationHelper > >::size_type n)"},
	 { "CalibrationHelperVector_capacity", _wrap_CalibrationHelperVector_capacity, METH_O, "CalibrationHelperVector_capacity(CalibrationHelperVector self) -> std::vector< ext::shared_ptr< CalibrationHelper > >::size_type"},
	 { "delete_CalibrationHelperVector", _wrap_delete_CalibrationHelperVector, METH_O, "delete_CalibrationHelperVector(CalibrationHelperVector self)"},
	 { "CalibrationHelperVector_swigregister", CalibrationHelperVector_swigregister, METH_O, NULL},
	 { "CalibrationHelperVector_swiginit", CalibrationHelperVector_swiginit, METH_VARARGS, NULL},
	 { "CalibratedModel_params", _wrap_CalibratedModel_params, METH_O, "CalibratedModel_params(CalibratedModel self) -> Array"},
	 { "CalibratedModel_calibrate", _wrap_CalibratedModel_calibrate, METH_VARARGS, "CalibratedModel_calibrate(CalibratedModel self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"},
	 { "CalibratedModel_setParams", _wrap_CalibratedModel_setParams, METH_VARARGS, "CalibratedModel_setParams(CalibratedModel self, Array params)"},
	 { "CalibratedModel_value", _wrap_CalibratedModel_value, METH_VARARGS, "CalibratedModel_value(CalibratedModel self, Array params, CalibrationHelperVector arg3) -> Real"},
	 { "CalibratedModel_constraint", _wrap_CalibratedModel_constraint, METH_O, "CalibratedModel_constraint(CalibratedModel self) -> ext::shared_ptr< Constraint > const &"},
	 { "CalibratedModel_endCriteria", _wrap_CalibratedModel_endCriteria, METH_O, "CalibratedModel_endCriteria(CalibratedModel self) -> EndCriteria::Type"},
	 { "CalibratedModel_problemValues", _wrap_CalibratedModel_problemValues, METH_O, "CalibratedModel_problemValues(CalibratedModel self) -> Array"},
	 { "CalibratedModel_functionEvaluation", _wrap_CalibratedModel_functionEvaluation, METH_O, "CalibratedModel_functionEvaluation(CalibratedModel self) -> Integer"},
	 { "delete_CalibratedModel", _wrap_delete_CalibratedModel, METH_O, "delete_CalibratedModel(CalibratedModel self)"},
	 { "CalibratedModel_swigregister", CalibratedModel_swigregister, METH_O, NULL},
	 { "TermStructureConsistentModel_termStructure", _wrap_TermStructureConsistentModel_termStructure, METH_O, "TermStructureConsistentModel_termStructure(TermStructureConsistentModel self) -> YieldTermStructureHandle"},
	 { "delete_TermStructureConsistentModel", _wrap_delete_TermStructureConsistentModel, METH_O, "delete_TermStructureConsistentModel(TermStructureConsistentModel self)"},
	 { "TermStructureConsistentModel_swigregister", TermStructureConsistentModel_swigregister, METH_O, NULL},
	 { "new_CalibratedModelHandle", _wrap_new_CalibratedModelHandle, METH_VARARGS, "CalibratedModelHandle(ext::shared_ptr< CalibratedModel > const & arg1=ext::shared_ptr())"},
	 { "CalibratedModelHandle___deref__", _wrap_CalibratedModelHandle___deref__, METH_O, "CalibratedModelHandle___deref__(CalibratedModelHandle self) -> ext::shared_ptr< CalibratedModel >"},
	 { "CalibratedModelHandle_currentLink", _wrap_CalibratedModelHandle_currentLink, METH_O, "CalibratedModelHandle_currentLink(CalibratedModelHandle self) -> ext::shared_ptr< CalibratedModel >"},
	 { "CalibratedModelHandle___nonzero__", _wrap_CalibratedModelHandle___nonzero__, METH_O, "CalibratedModelHandle___nonzero__(CalibratedModelHandle self) -> bool"},
	 { "CalibratedModelHandle___bool__", _wrap_CalibratedModelHandle___bool__, METH_O, "CalibratedModelHandle___bool__(CalibratedModelHandle self) -> bool"},
	 { "CalibratedModelHandle_asObservable", _wrap_CalibratedModelHandle_asObservable, METH_O, "CalibratedModelHandle_asObservable(CalibratedModelHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_CalibratedModelHandle", _wrap_delete_CalibratedModelHandle, METH_O, "delete_CalibratedModelHandle(CalibratedModelHandle self)"},
	 { "CalibratedModelHandle_params", _wrap_CalibratedModelHandle_params, METH_O, "CalibratedModelHandle_params(CalibratedModelHandle self) -> Array"},
	 { "CalibratedModelHandle_calibrate", _wrap_CalibratedModelHandle_calibrate, METH_VARARGS, "CalibratedModelHandle_calibrate(CalibratedModelHandle self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"},
	 { "CalibratedModelHandle_setParams", _wrap_CalibratedModelHandle_setParams, METH_VARARGS, "CalibratedModelHandle_setParams(CalibratedModelHandle self, Array params)"},
	 { "CalibratedModelHandle_value", _wrap_CalibratedModelHandle_value, METH_VARARGS, "CalibratedModelHandle_value(CalibratedModelHandle self, Array params, CalibrationHelperVector arg3) -> Real"},
	 { "CalibratedModelHandle_constraint", _wrap_CalibratedModelHandle_constraint, METH_O, "CalibratedModelHandle_constraint(CalibratedModelHandle self) -> ext::shared_ptr< Constraint > const &"},
	 { "CalibratedModelHandle_endCriteria", _wrap_CalibratedModelHandle_endCriteria, METH_O, "CalibratedModelHandle_endCriteria(CalibratedModelHandle self) -> EndCriteria::Type"},
	 { "CalibratedModelHandle_problemValues", _wrap_CalibratedModelHandle_problemValues, METH_O, "CalibratedModelHandle_problemValues(CalibratedModelHandle self) -> Array"},
	 { "CalibratedModelHandle_functionEvaluation", _wrap_CalibratedModelHandle_functionEvaluation, METH_O, "CalibratedModelHandle_functionEvaluation(CalibratedModelHandle self) -> Integer"},
	 { "CalibratedModelHandle_swigregister", CalibratedModelHandle_swigregister, METH_O, NULL},
	 { "CalibratedModelHandle_swiginit", CalibratedModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableCalibratedModelHandle", _wrap_new_RelinkableCalibratedModelHandle, METH_VARARGS, "RelinkableCalibratedModelHandle(ext::shared_ptr< CalibratedModel > const & arg1=ext::shared_ptr())"},
	 { "RelinkableCalibratedModelHandle_linkTo", _wrap_RelinkableCalibratedModelHandle_linkTo, METH_VARARGS, "RelinkableCalibratedModelHandle_linkTo(RelinkableCalibratedModelHandle self, ext::shared_ptr< CalibratedModel > const & arg2)"},
	 { "RelinkableCalibratedModelHandle_reset", _wrap_RelinkableCalibratedModelHandle_reset, METH_O, "RelinkableCalibratedModelHandle_reset(RelinkableCalibratedModelHandle self)"},
	 { "delete_RelinkableCalibratedModelHandle", _wrap_delete_RelinkableCalibratedModelHandle, METH_O, "delete_RelinkableCalibratedModelHandle(RelinkableCalibratedModelHandle self)"},
	 { "RelinkableCalibratedModelHandle_swigregister", RelinkableCalibratedModelHandle_swigregister, METH_O, NULL},
	 { "RelinkableCalibratedModelHandle_swiginit", RelinkableCalibratedModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_Parameter", _wrap_new_Parameter, METH_NOARGS, "new_Parameter() -> Parameter"},
	 { "Parameter_params", _wrap_Parameter_params, METH_O, "Parameter_params(Parameter self) -> Array"},
	 { "Parameter_setParam", _wrap_Parameter_setParam, METH_VARARGS, "Parameter_setParam(Parameter self, Size i, Real x)"},
	 { "Parameter_testParams", _wrap_Parameter_testParams, METH_VARARGS, "Parameter_testParams(Parameter self, Array params) -> bool"},
	 { "Parameter_size", _wrap_Parameter_size, METH_O, "Parameter_size(Parameter self) -> Size"},
	 { "Parameter___call__", _wrap_Parameter___call__, METH_VARARGS, "Parameter___call__(Parameter self, Time t) -> Real"},
	 { "Parameter_constraint", _wrap_Parameter_constraint, METH_O, "Parameter_constraint(Parameter self) -> Constraint"},
	 { "delete_Parameter", _wrap_delete_Parameter, METH_O, "delete_Parameter(Parameter self)"},
	 { "Parameter_swigregister", Parameter_swigregister, METH_O, NULL},
	 { "Parameter_swiginit", Parameter_swiginit, METH_VARARGS, NULL},
	 { "new_ConstantParameter", _wrap_new_ConstantParameter, METH_VARARGS, "\n"
		"ConstantParameter(Constraint constraint)\n"
		"new_ConstantParameter(Real value, Constraint constraint) -> ConstantParameter\n"
		""},
	 { "delete_ConstantParameter", _wrap_delete_ConstantParameter, METH_O, "delete_ConstantParameter(ConstantParameter self)"},
	 { "ConstantParameter_swigregister", ConstantParameter_swigregister, METH_O, NULL},
	 { "ConstantParameter_swiginit", ConstantParameter_swiginit, METH_VARARGS, NULL},
	 { "new_NullParameter", _wrap_new_NullParameter, METH_NOARGS, "new_NullParameter() -> NullParameter"},
	 { "delete_NullParameter", _wrap_delete_NullParameter, METH_O, "delete_NullParameter(NullParameter self)"},
	 { "NullParameter_swigregister", NullParameter_swigregister, METH_O, NULL},
	 { "NullParameter_swiginit", NullParameter_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseConstantParameter", _wrap_new_PiecewiseConstantParameter, METH_VARARGS, "PiecewiseConstantParameter(DoubleVector times, Constraint constraint=QuantLib::NoConstraint())"},
	 { "delete_PiecewiseConstantParameter", _wrap_delete_PiecewiseConstantParameter, METH_O, "delete_PiecewiseConstantParameter(PiecewiseConstantParameter self)"},
	 { "PiecewiseConstantParameter_swigregister", PiecewiseConstantParameter_swigregister, METH_O, NULL},
	 { "PiecewiseConstantParameter_swiginit", PiecewiseConstantParameter_swiginit, METH_VARARGS, NULL},
	 { "Payoff___call__", _wrap_Payoff___call__, METH_VARARGS, "Payoff___call__(Payoff self, Real price) -> Real"},
	 { "delete_Payoff", _wrap_delete_Payoff, METH_O, "delete_Payoff(Payoff self)"},
	 { "Payoff_swigregister", Payoff_swigregister, METH_O, NULL},
	 { "Option_payoff", _wrap_Option_payoff, METH_O, "Option_payoff(Option self) -> ext::shared_ptr< Payoff >"},
	 { "Option_exercise", _wrap_Option_exercise, METH_O, "Option_exercise(Option self) -> ext::shared_ptr< Exercise >"},
	 { "delete_Option", _wrap_delete_Option, METH_O, "delete_Option(Option self)"},
	 { "Option_swigregister", Option_swigregister, METH_O, NULL},
	 { "TypePayoff_optionType", _wrap_TypePayoff_optionType, METH_O, "TypePayoff_optionType(TypePayoff self) -> Option::Type"},
	 { "delete_TypePayoff", _wrap_delete_TypePayoff, METH_O, "delete_TypePayoff(TypePayoff self)"},
	 { "TypePayoff_swigregister", TypePayoff_swigregister, METH_O, NULL},
	 { "new_FloatingTypePayoff", _wrap_new_FloatingTypePayoff, METH_O, "new_FloatingTypePayoff(Option::Type type) -> FloatingTypePayoff"},
	 { "FloatingTypePayoff___call__", _wrap_FloatingTypePayoff___call__, METH_VARARGS, "\n"
		"FloatingTypePayoff___call__(FloatingTypePayoff self, Real price, Real strike) -> Real\n"
		"FloatingTypePayoff___call__(FloatingTypePayoff self, Real price) -> Real\n"
		""},
	 { "delete_FloatingTypePayoff", _wrap_delete_FloatingTypePayoff, METH_O, "delete_FloatingTypePayoff(FloatingTypePayoff self)"},
	 { "FloatingTypePayoff_swigregister", FloatingTypePayoff_swigregister, METH_O, NULL},
	 { "FloatingTypePayoff_swiginit", FloatingTypePayoff_swiginit, METH_VARARGS, NULL},
	 { "StrikedTypePayoff_strike", _wrap_StrikedTypePayoff_strike, METH_O, "StrikedTypePayoff_strike(StrikedTypePayoff self) -> Real"},
	 { "delete_StrikedTypePayoff", _wrap_delete_StrikedTypePayoff, METH_O, "delete_StrikedTypePayoff(StrikedTypePayoff self)"},
	 { "StrikedTypePayoff_swigregister", StrikedTypePayoff_swigregister, METH_O, NULL},
	 { "new_DeltaVolQuote", _wrap_new_DeltaVolQuote, METH_VARARGS, "\n"
		"DeltaVolQuote(Real delta, QuoteHandle vol, Time maturity, DeltaVolQuote::DeltaType deltaType)\n"
		"new_DeltaVolQuote(QuoteHandle vol, DeltaVolQuote::DeltaType deltaType, Time maturity, DeltaVolQuote::AtmType atmType) -> DeltaVolQuote\n"
		""},
	 { "DeltaVolQuote_delta", _wrap_DeltaVolQuote_delta, METH_O, "DeltaVolQuote_delta(DeltaVolQuote self) -> Real"},
	 { "DeltaVolQuote_maturity", _wrap_DeltaVolQuote_maturity, METH_O, "DeltaVolQuote_maturity(DeltaVolQuote self) -> Time"},
	 { "DeltaVolQuote_atmType", _wrap_DeltaVolQuote_atmType, METH_O, "DeltaVolQuote_atmType(DeltaVolQuote self) -> DeltaVolQuote::AtmType"},
	 { "DeltaVolQuote_deltaType", _wrap_DeltaVolQuote_deltaType, METH_O, "DeltaVolQuote_deltaType(DeltaVolQuote self) -> DeltaVolQuote::DeltaType"},
	 { "delete_DeltaVolQuote", _wrap_delete_DeltaVolQuote, METH_O, "delete_DeltaVolQuote(DeltaVolQuote self)"},
	 { "DeltaVolQuote_swigregister", DeltaVolQuote_swigregister, METH_O, NULL},
	 { "DeltaVolQuote_swiginit", DeltaVolQuote_swiginit, METH_VARARGS, NULL},
	 { "new_DeltaVolQuoteHandle", _wrap_new_DeltaVolQuoteHandle, METH_VARARGS, "DeltaVolQuoteHandle(ext::shared_ptr< DeltaVolQuote > const & arg1=ext::shared_ptr())"},
	 { "DeltaVolQuoteHandle___deref__", _wrap_DeltaVolQuoteHandle___deref__, METH_O, "DeltaVolQuoteHandle___deref__(DeltaVolQuoteHandle self) -> ext::shared_ptr< DeltaVolQuote >"},
	 { "DeltaVolQuoteHandle_currentLink", _wrap_DeltaVolQuoteHandle_currentLink, METH_O, "DeltaVolQuoteHandle_currentLink(DeltaVolQuoteHandle self) -> ext::shared_ptr< DeltaVolQuote >"},
	 { "DeltaVolQuoteHandle___nonzero__", _wrap_DeltaVolQuoteHandle___nonzero__, METH_O, "DeltaVolQuoteHandle___nonzero__(DeltaVolQuoteHandle self) -> bool"},
	 { "DeltaVolQuoteHandle___bool__", _wrap_DeltaVolQuoteHandle___bool__, METH_O, "DeltaVolQuoteHandle___bool__(DeltaVolQuoteHandle self) -> bool"},
	 { "DeltaVolQuoteHandle_asObservable", _wrap_DeltaVolQuoteHandle_asObservable, METH_O, "DeltaVolQuoteHandle_asObservable(DeltaVolQuoteHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_DeltaVolQuoteHandle", _wrap_delete_DeltaVolQuoteHandle, METH_O, "delete_DeltaVolQuoteHandle(DeltaVolQuoteHandle self)"},
	 { "DeltaVolQuoteHandle_delta", _wrap_DeltaVolQuoteHandle_delta, METH_O, "DeltaVolQuoteHandle_delta(DeltaVolQuoteHandle self) -> Real"},
	 { "DeltaVolQuoteHandle_maturity", _wrap_DeltaVolQuoteHandle_maturity, METH_O, "DeltaVolQuoteHandle_maturity(DeltaVolQuoteHandle self) -> Time"},
	 { "DeltaVolQuoteHandle_atmType", _wrap_DeltaVolQuoteHandle_atmType, METH_O, "DeltaVolQuoteHandle_atmType(DeltaVolQuoteHandle self) -> DeltaVolQuote::AtmType"},
	 { "DeltaVolQuoteHandle_deltaType", _wrap_DeltaVolQuoteHandle_deltaType, METH_O, "DeltaVolQuoteHandle_deltaType(DeltaVolQuoteHandle self) -> DeltaVolQuote::DeltaType"},
	 { "DeltaVolQuoteHandle_value", _wrap_DeltaVolQuoteHandle_value, METH_O, "DeltaVolQuoteHandle_value(DeltaVolQuoteHandle self) -> Real"},
	 { "DeltaVolQuoteHandle_isValid", _wrap_DeltaVolQuoteHandle_isValid, METH_O, "DeltaVolQuoteHandle_isValid(DeltaVolQuoteHandle self) -> bool"},
	 { "DeltaVolQuoteHandle_swigregister", DeltaVolQuoteHandle_swigregister, METH_O, NULL},
	 { "DeltaVolQuoteHandle_swiginit", DeltaVolQuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableDeltaVolQuoteHandle", _wrap_new_RelinkableDeltaVolQuoteHandle, METH_VARARGS, "RelinkableDeltaVolQuoteHandle(ext::shared_ptr< DeltaVolQuote > const & arg1=ext::shared_ptr())"},
	 { "RelinkableDeltaVolQuoteHandle_linkTo", _wrap_RelinkableDeltaVolQuoteHandle_linkTo, METH_VARARGS, "RelinkableDeltaVolQuoteHandle_linkTo(RelinkableDeltaVolQuoteHandle self, ext::shared_ptr< DeltaVolQuote > const & arg2)"},
	 { "RelinkableDeltaVolQuoteHandle_reset", _wrap_RelinkableDeltaVolQuoteHandle_reset, METH_O, "RelinkableDeltaVolQuoteHandle_reset(RelinkableDeltaVolQuoteHandle self)"},
	 { "delete_RelinkableDeltaVolQuoteHandle", _wrap_delete_RelinkableDeltaVolQuoteHandle, METH_O, "delete_RelinkableDeltaVolQuoteHandle(RelinkableDeltaVolQuoteHandle self)"},
	 { "RelinkableDeltaVolQuoteHandle_swigregister", RelinkableDeltaVolQuoteHandle_swigregister, METH_O, NULL},
	 { "RelinkableDeltaVolQuoteHandle_swiginit", RelinkableDeltaVolQuoteHandle_swiginit, METH_VARARGS, NULL},
	 { "OneAssetOption_delta", _wrap_OneAssetOption_delta, METH_O, "OneAssetOption_delta(OneAssetOption self) -> Real"},
	 { "OneAssetOption_deltaForward", _wrap_OneAssetOption_deltaForward, METH_O, "OneAssetOption_deltaForward(OneAssetOption self) -> Real"},
	 { "OneAssetOption_elasticity", _wrap_OneAssetOption_elasticity, METH_O, "OneAssetOption_elasticity(OneAssetOption self) -> Real"},
	 { "OneAssetOption_gamma", _wrap_OneAssetOption_gamma, METH_O, "OneAssetOption_gamma(OneAssetOption self) -> Real"},
	 { "OneAssetOption_theta", _wrap_OneAssetOption_theta, METH_O, "OneAssetOption_theta(OneAssetOption self) -> Real"},
	 { "OneAssetOption_thetaPerDay", _wrap_OneAssetOption_thetaPerDay, METH_O, "OneAssetOption_thetaPerDay(OneAssetOption self) -> Real"},
	 { "OneAssetOption_vega", _wrap_OneAssetOption_vega, METH_O, "OneAssetOption_vega(OneAssetOption self) -> Real"},
	 { "OneAssetOption_rho", _wrap_OneAssetOption_rho, METH_O, "OneAssetOption_rho(OneAssetOption self) -> Real"},
	 { "OneAssetOption_dividendRho", _wrap_OneAssetOption_dividendRho, METH_O, "OneAssetOption_dividendRho(OneAssetOption self) -> Real"},
	 { "OneAssetOption_strikeSensitivity", _wrap_OneAssetOption_strikeSensitivity, METH_O, "OneAssetOption_strikeSensitivity(OneAssetOption self) -> Real"},
	 { "OneAssetOption_itmCashProbability", _wrap_OneAssetOption_itmCashProbability, METH_O, "OneAssetOption_itmCashProbability(OneAssetOption self) -> Real"},
	 { "delete_OneAssetOption", _wrap_delete_OneAssetOption, METH_O, "delete_OneAssetOption(OneAssetOption self)"},
	 { "OneAssetOption_swigregister", OneAssetOption_swigregister, METH_O, NULL},
	 { "new_VanillaOption", _wrap_new_VanillaOption, METH_VARARGS, "new_VanillaOption(ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> VanillaOption"},
	 { "VanillaOption_impliedVolatility", _wrap_VanillaOption_impliedVolatility, METH_VARARGS, "\n"
		"VanillaOption_impliedVolatility(VanillaOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility\n"
		"VanillaOption_impliedVolatility(VanillaOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility\n"
		""},
	 { "VanillaOption_priceCurve", _wrap_VanillaOption_priceCurve, METH_O, "VanillaOption_priceCurve(VanillaOption self) -> SampledCurve"},
	 { "delete_VanillaOption", _wrap_delete_VanillaOption, METH_O, "delete_VanillaOption(VanillaOption self)"},
	 { "VanillaOption_swigregister", VanillaOption_swigregister, METH_O, NULL},
	 { "VanillaOption_swiginit", VanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_CalibrationPair", _wrap_new_CalibrationPair, METH_VARARGS, "\n"
		"CalibrationPair()\n"
		"CalibrationPair(ext::shared_ptr< VanillaOption > first, ext::shared_ptr< Quote > second)\n"
		"new_CalibrationPair(CalibrationPair other) -> CalibrationPair\n"
		""},
	 { "CalibrationPair_first_set", _wrap_CalibrationPair_first_set, METH_VARARGS, "CalibrationPair_first_set(CalibrationPair self, ext::shared_ptr< VanillaOption > const & first)"},
	 { "CalibrationPair_first_get", _wrap_CalibrationPair_first_get, METH_O, "CalibrationPair_first_get(CalibrationPair self) -> ext::shared_ptr< VanillaOption > const &"},
	 { "CalibrationPair_second_set", _wrap_CalibrationPair_second_set, METH_VARARGS, "CalibrationPair_second_set(CalibrationPair self, ext::shared_ptr< Quote > const & second)"},
	 { "CalibrationPair_second_get", _wrap_CalibrationPair_second_get, METH_O, "CalibrationPair_second_get(CalibrationPair self) -> ext::shared_ptr< Quote > const &"},
	 { "delete_CalibrationPair", _wrap_delete_CalibrationPair, METH_O, "delete_CalibrationPair(CalibrationPair self)"},
	 { "CalibrationPair_swigregister", CalibrationPair_swigregister, METH_O, NULL},
	 { "CalibrationPair_swiginit", CalibrationPair_swiginit, METH_VARARGS, NULL},
	 { "CalibrationSet_iterator", _wrap_CalibrationSet_iterator, METH_O, "CalibrationSet_iterator(CalibrationSet self) -> SwigPyIterator"},
	 { "CalibrationSet___nonzero__", _wrap_CalibrationSet___nonzero__, METH_O, "CalibrationSet___nonzero__(CalibrationSet self) -> bool"},
	 { "CalibrationSet___bool__", _wrap_CalibrationSet___bool__, METH_O, "CalibrationSet___bool__(CalibrationSet self) -> bool"},
	 { "CalibrationSet___len__", _wrap_CalibrationSet___len__, METH_O, "CalibrationSet___len__(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type"},
	 { "CalibrationSet___getslice__", _wrap_CalibrationSet___getslice__, METH_VARARGS, "CalibrationSet___getslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j) -> CalibrationSet"},
	 { "CalibrationSet___setslice__", _wrap_CalibrationSet___setslice__, METH_VARARGS, "\n"
		"CalibrationSet___setslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j)\n"
		"CalibrationSet___setslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j, CalibrationSet v)\n"
		""},
	 { "CalibrationSet___delslice__", _wrap_CalibrationSet___delslice__, METH_VARARGS, "CalibrationSet___delslice__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type j)"},
	 { "CalibrationSet___delitem__", _wrap_CalibrationSet___delitem__, METH_VARARGS, "\n"
		"CalibrationSet___delitem__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i)\n"
		"CalibrationSet___delitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "CalibrationSet___getitem__", _wrap_CalibrationSet___getitem__, METH_VARARGS, "\n"
		"CalibrationSet___getitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice) -> CalibrationSet\n"
		"CalibrationSet___getitem__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i) -> CalibrationPair\n"
		""},
	 { "CalibrationSet___setitem__", _wrap_CalibrationSet___setitem__, METH_VARARGS, "\n"
		"CalibrationSet___setitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice, CalibrationSet v)\n"
		"CalibrationSet___setitem__(CalibrationSet self, SWIGPY_SLICEOBJECT * slice)\n"
		"CalibrationSet___setitem__(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::difference_type i, CalibrationPair x)\n"
		""},
	 { "CalibrationSet_pop", _wrap_CalibrationSet_pop, METH_O, "CalibrationSet_pop(CalibrationSet self) -> CalibrationPair"},
	 { "CalibrationSet_append", _wrap_CalibrationSet_append, METH_VARARGS, "CalibrationSet_append(CalibrationSet self, CalibrationPair x)"},
	 { "CalibrationSet_empty", _wrap_CalibrationSet_empty, METH_O, "CalibrationSet_empty(CalibrationSet self) -> bool"},
	 { "CalibrationSet_size", _wrap_CalibrationSet_size, METH_O, "CalibrationSet_size(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type"},
	 { "CalibrationSet_swap", _wrap_CalibrationSet_swap, METH_VARARGS, "CalibrationSet_swap(CalibrationSet self, CalibrationSet v)"},
	 { "CalibrationSet_begin", _wrap_CalibrationSet_begin, METH_O, "CalibrationSet_begin(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator"},
	 { "CalibrationSet_end", _wrap_CalibrationSet_end, METH_O, "CalibrationSet_end(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator"},
	 { "CalibrationSet_rbegin", _wrap_CalibrationSet_rbegin, METH_O, "CalibrationSet_rbegin(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator"},
	 { "CalibrationSet_rend", _wrap_CalibrationSet_rend, METH_O, "CalibrationSet_rend(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::reverse_iterator"},
	 { "CalibrationSet_clear", _wrap_CalibrationSet_clear, METH_O, "CalibrationSet_clear(CalibrationSet self)"},
	 { "CalibrationSet_get_allocator", _wrap_CalibrationSet_get_allocator, METH_O, "CalibrationSet_get_allocator(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::allocator_type"},
	 { "CalibrationSet_pop_back", _wrap_CalibrationSet_pop_back, METH_O, "CalibrationSet_pop_back(CalibrationSet self)"},
	 { "CalibrationSet_erase", _wrap_CalibrationSet_erase, METH_VARARGS, "\n"
		"CalibrationSet_erase(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator\n"
		"CalibrationSet_erase(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator first, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator last) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator\n"
		""},
	 { "new_CalibrationSet", _wrap_new_CalibrationSet, METH_VARARGS, "\n"
		"CalibrationSet()\n"
		"CalibrationSet(CalibrationSet other)\n"
		"CalibrationSet(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type size)\n"
		"new_CalibrationSet(std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type size, CalibrationPair value) -> CalibrationSet\n"
		""},
	 { "CalibrationSet_push_back", _wrap_CalibrationSet_push_back, METH_VARARGS, "CalibrationSet_push_back(CalibrationSet self, CalibrationPair x)"},
	 { "CalibrationSet_front", _wrap_CalibrationSet_front, METH_O, "CalibrationSet_front(CalibrationSet self) -> CalibrationPair"},
	 { "CalibrationSet_back", _wrap_CalibrationSet_back, METH_O, "CalibrationSet_back(CalibrationSet self) -> CalibrationPair"},
	 { "CalibrationSet_assign", _wrap_CalibrationSet_assign, METH_VARARGS, "CalibrationSet_assign(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n, CalibrationPair x)"},
	 { "CalibrationSet_resize", _wrap_CalibrationSet_resize, METH_VARARGS, "\n"
		"CalibrationSet_resize(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type new_size)\n"
		"CalibrationSet_resize(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type new_size, CalibrationPair x)\n"
		""},
	 { "CalibrationSet_insert", _wrap_CalibrationSet_insert, METH_VARARGS, "\n"
		"CalibrationSet_insert(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos, CalibrationPair x) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator\n"
		"CalibrationSet_insert(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::iterator pos, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n, CalibrationPair x)\n"
		""},
	 { "CalibrationSet_reserve", _wrap_CalibrationSet_reserve, METH_VARARGS, "CalibrationSet_reserve(CalibrationSet self, std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type n)"},
	 { "CalibrationSet_capacity", _wrap_CalibrationSet_capacity, METH_O, "CalibrationSet_capacity(CalibrationSet self) -> std::vector< std::pair< ext::shared_ptr< VanillaOption >,ext::shared_ptr< Quote > > >::size_type"},
	 { "delete_CalibrationSet", _wrap_delete_CalibrationSet, METH_O, "delete_CalibrationSet(CalibrationSet self)"},
	 { "CalibrationSet_swigregister", CalibrationSet_swigregister, METH_O, NULL},
	 { "CalibrationSet_swiginit", CalibrationSet_swiginit, METH_VARARGS, NULL},
	 { "new_EuropeanOption", _wrap_new_EuropeanOption, METH_VARARGS, "new_EuropeanOption(ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> EuropeanOption"},
	 { "delete_EuropeanOption", _wrap_delete_EuropeanOption, METH_O, "delete_EuropeanOption(EuropeanOption self)"},
	 { "EuropeanOption_swigregister", EuropeanOption_swigregister, METH_O, NULL},
	 { "EuropeanOption_swiginit", EuropeanOption_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardVanillaOption", _wrap_new_ForwardVanillaOption, METH_VARARGS, "new_ForwardVanillaOption(Real moneyness, Date resetDate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ForwardVanillaOption"},
	 { "delete_ForwardVanillaOption", _wrap_delete_ForwardVanillaOption, METH_O, "delete_ForwardVanillaOption(ForwardVanillaOption self)"},
	 { "ForwardVanillaOption_swigregister", ForwardVanillaOption_swigregister, METH_O, NULL},
	 { "ForwardVanillaOption_swiginit", ForwardVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoVanillaOption", _wrap_new_QuantoVanillaOption, METH_VARARGS, "new_QuantoVanillaOption(ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoVanillaOption"},
	 { "QuantoVanillaOption_qvega", _wrap_QuantoVanillaOption_qvega, METH_O, "QuantoVanillaOption_qvega(QuantoVanillaOption self) -> Real"},
	 { "QuantoVanillaOption_qrho", _wrap_QuantoVanillaOption_qrho, METH_O, "QuantoVanillaOption_qrho(QuantoVanillaOption self) -> Real"},
	 { "QuantoVanillaOption_qlambda", _wrap_QuantoVanillaOption_qlambda, METH_O, "QuantoVanillaOption_qlambda(QuantoVanillaOption self) -> Real"},
	 { "delete_QuantoVanillaOption", _wrap_delete_QuantoVanillaOption, METH_O, "delete_QuantoVanillaOption(QuantoVanillaOption self)"},
	 { "QuantoVanillaOption_swigregister", QuantoVanillaOption_swigregister, METH_O, NULL},
	 { "QuantoVanillaOption_swiginit", QuantoVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoForwardVanillaOption", _wrap_new_QuantoForwardVanillaOption, METH_VARARGS, "new_QuantoForwardVanillaOption(Real moneyness, Date resetDate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoForwardVanillaOption"},
	 { "delete_QuantoForwardVanillaOption", _wrap_delete_QuantoForwardVanillaOption, METH_O, "delete_QuantoForwardVanillaOption(QuantoForwardVanillaOption self)"},
	 { "QuantoForwardVanillaOption_swigregister", QuantoForwardVanillaOption_swigregister, METH_O, NULL},
	 { "QuantoForwardVanillaOption_swiginit", QuantoForwardVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "MultiAssetOption_delta", _wrap_MultiAssetOption_delta, METH_O, "MultiAssetOption_delta(MultiAssetOption self) -> Real"},
	 { "MultiAssetOption_gamma", _wrap_MultiAssetOption_gamma, METH_O, "MultiAssetOption_gamma(MultiAssetOption self) -> Real"},
	 { "MultiAssetOption_theta", _wrap_MultiAssetOption_theta, METH_O, "MultiAssetOption_theta(MultiAssetOption self) -> Real"},
	 { "MultiAssetOption_vega", _wrap_MultiAssetOption_vega, METH_O, "MultiAssetOption_vega(MultiAssetOption self) -> Real"},
	 { "MultiAssetOption_rho", _wrap_MultiAssetOption_rho, METH_O, "MultiAssetOption_rho(MultiAssetOption self) -> Real"},
	 { "MultiAssetOption_dividendRho", _wrap_MultiAssetOption_dividendRho, METH_O, "MultiAssetOption_dividendRho(MultiAssetOption self) -> Real"},
	 { "delete_MultiAssetOption", _wrap_delete_MultiAssetOption, METH_O, "delete_MultiAssetOption(MultiAssetOption self)"},
	 { "MultiAssetOption_swigregister", MultiAssetOption_swigregister, METH_O, NULL},
	 { "new_AnalyticEuropeanEngine", _wrap_new_AnalyticEuropeanEngine, METH_VARARGS, "\n"
		"AnalyticEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process)\n"
		"new_AnalyticEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, YieldTermStructureHandle discountCurve) -> AnalyticEuropeanEngine\n"
		""},
	 { "delete_AnalyticEuropeanEngine", _wrap_delete_AnalyticEuropeanEngine, METH_O, "delete_AnalyticEuropeanEngine(AnalyticEuropeanEngine self)"},
	 { "AnalyticEuropeanEngine_swigregister", AnalyticEuropeanEngine_swigregister, METH_O, NULL},
	 { "AnalyticEuropeanEngine_swiginit", AnalyticEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_HestonModel", _wrap_new_HestonModel, METH_O, "new_HestonModel(ext::shared_ptr< HestonProcess > const & process) -> HestonModel"},
	 { "HestonModel_theta", _wrap_HestonModel_theta, METH_O, "HestonModel_theta(HestonModel self) -> Real"},
	 { "HestonModel_kappa", _wrap_HestonModel_kappa, METH_O, "HestonModel_kappa(HestonModel self) -> Real"},
	 { "HestonModel_sigma", _wrap_HestonModel_sigma, METH_O, "HestonModel_sigma(HestonModel self) -> Real"},
	 { "HestonModel_rho", _wrap_HestonModel_rho, METH_O, "HestonModel_rho(HestonModel self) -> Real"},
	 { "HestonModel_v0", _wrap_HestonModel_v0, METH_O, "HestonModel_v0(HestonModel self) -> Real"},
	 { "delete_HestonModel", _wrap_delete_HestonModel, METH_O, "delete_HestonModel(HestonModel self)"},
	 { "HestonModel_swigregister", HestonModel_swigregister, METH_O, NULL},
	 { "HestonModel_swiginit", HestonModel_swiginit, METH_VARARGS, NULL},
	 { "new_HestonModelHandle", _wrap_new_HestonModelHandle, METH_VARARGS, "HestonModelHandle(ext::shared_ptr< HestonModel > const & arg1=ext::shared_ptr())"},
	 { "HestonModelHandle___deref__", _wrap_HestonModelHandle___deref__, METH_O, "HestonModelHandle___deref__(HestonModelHandle self) -> ext::shared_ptr< HestonModel >"},
	 { "HestonModelHandle_currentLink", _wrap_HestonModelHandle_currentLink, METH_O, "HestonModelHandle_currentLink(HestonModelHandle self) -> ext::shared_ptr< HestonModel >"},
	 { "HestonModelHandle___nonzero__", _wrap_HestonModelHandle___nonzero__, METH_O, "HestonModelHandle___nonzero__(HestonModelHandle self) -> bool"},
	 { "HestonModelHandle___bool__", _wrap_HestonModelHandle___bool__, METH_O, "HestonModelHandle___bool__(HestonModelHandle self) -> bool"},
	 { "HestonModelHandle_asObservable", _wrap_HestonModelHandle_asObservable, METH_O, "HestonModelHandle_asObservable(HestonModelHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_HestonModelHandle", _wrap_delete_HestonModelHandle, METH_O, "delete_HestonModelHandle(HestonModelHandle self)"},
	 { "HestonModelHandle_theta", _wrap_HestonModelHandle_theta, METH_O, "HestonModelHandle_theta(HestonModelHandle self) -> Real"},
	 { "HestonModelHandle_kappa", _wrap_HestonModelHandle_kappa, METH_O, "HestonModelHandle_kappa(HestonModelHandle self) -> Real"},
	 { "HestonModelHandle_sigma", _wrap_HestonModelHandle_sigma, METH_O, "HestonModelHandle_sigma(HestonModelHandle self) -> Real"},
	 { "HestonModelHandle_rho", _wrap_HestonModelHandle_rho, METH_O, "HestonModelHandle_rho(HestonModelHandle self) -> Real"},
	 { "HestonModelHandle_v0", _wrap_HestonModelHandle_v0, METH_O, "HestonModelHandle_v0(HestonModelHandle self) -> Real"},
	 { "HestonModelHandle_params", _wrap_HestonModelHandle_params, METH_O, "HestonModelHandle_params(HestonModelHandle self) -> Array"},
	 { "HestonModelHandle_calibrate", _wrap_HestonModelHandle_calibrate, METH_VARARGS, "HestonModelHandle_calibrate(HestonModelHandle self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"},
	 { "HestonModelHandle_setParams", _wrap_HestonModelHandle_setParams, METH_VARARGS, "HestonModelHandle_setParams(HestonModelHandle self, Array params)"},
	 { "HestonModelHandle_value", _wrap_HestonModelHandle_value, METH_VARARGS, "HestonModelHandle_value(HestonModelHandle self, Array params, CalibrationHelperVector arg3) -> Real"},
	 { "HestonModelHandle_constraint", _wrap_HestonModelHandle_constraint, METH_O, "HestonModelHandle_constraint(HestonModelHandle self) -> ext::shared_ptr< Constraint > const &"},
	 { "HestonModelHandle_endCriteria", _wrap_HestonModelHandle_endCriteria, METH_O, "HestonModelHandle_endCriteria(HestonModelHandle self) -> EndCriteria::Type"},
	 { "HestonModelHandle_problemValues", _wrap_HestonModelHandle_problemValues, METH_O, "HestonModelHandle_problemValues(HestonModelHandle self) -> Array"},
	 { "HestonModelHandle_functionEvaluation", _wrap_HestonModelHandle_functionEvaluation, METH_O, "HestonModelHandle_functionEvaluation(HestonModelHandle self) -> Integer"},
	 { "HestonModelHandle_swigregister", HestonModelHandle_swigregister, METH_O, NULL},
	 { "HestonModelHandle_swiginit", HestonModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseTimeDependentHestonModel", _wrap_new_PiecewiseTimeDependentHestonModel, METH_VARARGS, "new_PiecewiseTimeDependentHestonModel(YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, QuoteHandle s0, Real v0, Parameter theta, Parameter kappa, Parameter sigma, Parameter rho, TimeGrid timeGrid) -> PiecewiseTimeDependentHestonModel"},
	 { "PiecewiseTimeDependentHestonModel_theta", _wrap_PiecewiseTimeDependentHestonModel_theta, METH_VARARGS, "PiecewiseTimeDependentHestonModel_theta(PiecewiseTimeDependentHestonModel self, Time t) -> Real"},
	 { "PiecewiseTimeDependentHestonModel_kappa", _wrap_PiecewiseTimeDependentHestonModel_kappa, METH_VARARGS, "PiecewiseTimeDependentHestonModel_kappa(PiecewiseTimeDependentHestonModel self, Time t) -> Real"},
	 { "PiecewiseTimeDependentHestonModel_sigma", _wrap_PiecewiseTimeDependentHestonModel_sigma, METH_VARARGS, "PiecewiseTimeDependentHestonModel_sigma(PiecewiseTimeDependentHestonModel self, Time t) -> Real"},
	 { "PiecewiseTimeDependentHestonModel_rho", _wrap_PiecewiseTimeDependentHestonModel_rho, METH_VARARGS, "PiecewiseTimeDependentHestonModel_rho(PiecewiseTimeDependentHestonModel self, Time t) -> Real"},
	 { "PiecewiseTimeDependentHestonModel_v0", _wrap_PiecewiseTimeDependentHestonModel_v0, METH_O, "PiecewiseTimeDependentHestonModel_v0(PiecewiseTimeDependentHestonModel self) -> Real"},
	 { "PiecewiseTimeDependentHestonModel_s0", _wrap_PiecewiseTimeDependentHestonModel_s0, METH_O, "PiecewiseTimeDependentHestonModel_s0(PiecewiseTimeDependentHestonModel self) -> Real"},
	 { "PiecewiseTimeDependentHestonModel_timeGrid", _wrap_PiecewiseTimeDependentHestonModel_timeGrid, METH_O, "PiecewiseTimeDependentHestonModel_timeGrid(PiecewiseTimeDependentHestonModel self) -> TimeGrid"},
	 { "PiecewiseTimeDependentHestonModel_dividendYield", _wrap_PiecewiseTimeDependentHestonModel_dividendYield, METH_O, "PiecewiseTimeDependentHestonModel_dividendYield(PiecewiseTimeDependentHestonModel self) -> YieldTermStructureHandle"},
	 { "PiecewiseTimeDependentHestonModel_riskFreeRate", _wrap_PiecewiseTimeDependentHestonModel_riskFreeRate, METH_O, "PiecewiseTimeDependentHestonModel_riskFreeRate(PiecewiseTimeDependentHestonModel self) -> YieldTermStructureHandle"},
	 { "delete_PiecewiseTimeDependentHestonModel", _wrap_delete_PiecewiseTimeDependentHestonModel, METH_O, "delete_PiecewiseTimeDependentHestonModel(PiecewiseTimeDependentHestonModel self)"},
	 { "PiecewiseTimeDependentHestonModel_swigregister", PiecewiseTimeDependentHestonModel_swigregister, METH_O, NULL},
	 { "PiecewiseTimeDependentHestonModel_swiginit", PiecewiseTimeDependentHestonModel_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticHestonEngine", _wrap_new_AnalyticHestonEngine, METH_VARARGS, "\n"
		"AnalyticHestonEngine(ext::shared_ptr< HestonModel > const & model, Size integrationOrder=144)\n"
		"AnalyticHestonEngine(ext::shared_ptr< HestonModel > const & model, Real relTolerance, Size maxEvaluations)\n"
		"AnalyticHestonEngine(ext::shared_ptr< HestonModel > const & model, AnalyticHestonEngine::ComplexLogFormula cpxLog, AnalyticHestonEngine_Integration itg, Real andersenPiterbargEpsilon=1e-8)\n"
		""},
	 { "AnalyticHestonEngine_numberOfEvaluations", _wrap_AnalyticHestonEngine_numberOfEvaluations, METH_O, "AnalyticHestonEngine_numberOfEvaluations(AnalyticHestonEngine self) -> Size"},
	 { "AnalyticHestonEngine_chF", _wrap_AnalyticHestonEngine_chF, METH_VARARGS, "AnalyticHestonEngine_chF(AnalyticHestonEngine self, std::complex< Real > const & z, Time t) -> std::complex< Real >"},
	 { "AnalyticHestonEngine_lnChF", _wrap_AnalyticHestonEngine_lnChF, METH_VARARGS, "AnalyticHestonEngine_lnChF(AnalyticHestonEngine self, std::complex< Real > const & z, Time t) -> std::complex< Real >"},
	 { "delete_AnalyticHestonEngine", _wrap_delete_AnalyticHestonEngine, METH_O, "delete_AnalyticHestonEngine(AnalyticHestonEngine self)"},
	 { "AnalyticHestonEngine_swigregister", AnalyticHestonEngine_swigregister, METH_O, NULL},
	 { "AnalyticHestonEngine_swiginit", AnalyticHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "AnalyticHestonEngine_Integration_gaussLaguerre", _wrap_AnalyticHestonEngine_Integration_gaussLaguerre, METH_VARARGS, "AnalyticHestonEngine_Integration_gaussLaguerre(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_gaussLegendre", _wrap_AnalyticHestonEngine_Integration_gaussLegendre, METH_VARARGS, "AnalyticHestonEngine_Integration_gaussLegendre(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_gaussChebyshev", _wrap_AnalyticHestonEngine_Integration_gaussChebyshev, METH_VARARGS, "AnalyticHestonEngine_Integration_gaussChebyshev(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_gaussChebyshev2nd", _wrap_AnalyticHestonEngine_Integration_gaussChebyshev2nd, METH_VARARGS, "AnalyticHestonEngine_Integration_gaussChebyshev2nd(Size integrationOrder=128) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_gaussLobatto", _wrap_AnalyticHestonEngine_Integration_gaussLobatto, METH_VARARGS, "AnalyticHestonEngine_Integration_gaussLobatto(Real relTolerance, Real absTolerance, Size maxEvaluations=1000, bool useConvergenceEstimate=False) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_gaussKronrod", _wrap_AnalyticHestonEngine_Integration_gaussKronrod, METH_VARARGS, "AnalyticHestonEngine_Integration_gaussKronrod(Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_simpson", _wrap_AnalyticHestonEngine_Integration_simpson, METH_VARARGS, "AnalyticHestonEngine_Integration_simpson(Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_trapezoid", _wrap_AnalyticHestonEngine_Integration_trapezoid, METH_VARARGS, "AnalyticHestonEngine_Integration_trapezoid(Real absTolerance, Size maxEvaluations=1000) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_discreteSimpson", _wrap_AnalyticHestonEngine_Integration_discreteSimpson, METH_VARARGS, "AnalyticHestonEngine_Integration_discreteSimpson(Size evaluation=1000) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_discreteTrapezoid", _wrap_AnalyticHestonEngine_Integration_discreteTrapezoid, METH_VARARGS, "AnalyticHestonEngine_Integration_discreteTrapezoid(Size evaluation=1000) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_expSinh", _wrap_AnalyticHestonEngine_Integration_expSinh, METH_VARARGS, "AnalyticHestonEngine_Integration_expSinh(Real relTolerance=1e-8) -> AnalyticHestonEngine_Integration"},
	 { "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit", _wrap_AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit, METH_VARARGS, "AnalyticHestonEngine_Integration_andersenPiterbargIntegrationLimit(Real c_inf, Real epsilon, Real v0, Real t) -> Real"},
	 { "AnalyticHestonEngine_Integration_numberOfEvaluations", _wrap_AnalyticHestonEngine_Integration_numberOfEvaluations, METH_O, "AnalyticHestonEngine_Integration_numberOfEvaluations(AnalyticHestonEngine_Integration self) -> Size"},
	 { "AnalyticHestonEngine_Integration_isAdaptiveIntegration", _wrap_AnalyticHestonEngine_Integration_isAdaptiveIntegration, METH_O, "AnalyticHestonEngine_Integration_isAdaptiveIntegration(AnalyticHestonEngine_Integration self) -> bool"},
	 { "delete_AnalyticHestonEngine_Integration", _wrap_delete_AnalyticHestonEngine_Integration, METH_O, "delete_AnalyticHestonEngine_Integration(AnalyticHestonEngine_Integration self)"},
	 { "AnalyticHestonEngine_Integration_swigregister", AnalyticHestonEngine_Integration_swigregister, METH_O, NULL},
	 { "new_AnalyticHestonEngine_OptimalAlpha", _wrap_new_AnalyticHestonEngine_OptimalAlpha, METH_VARARGS, "new_AnalyticHestonEngine_OptimalAlpha(Time const t, ext::shared_ptr< AnalyticHestonEngine > const & engine) -> AnalyticHestonEngine_OptimalAlpha"},
	 { "AnalyticHestonEngine_OptimalAlpha___call__", _wrap_AnalyticHestonEngine_OptimalAlpha___call__, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha___call__(AnalyticHestonEngine_OptimalAlpha self, Real strike) -> Real"},
	 { "AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero", _wrap_AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha_alphaGreaterZero(AnalyticHestonEngine_OptimalAlpha self, Real strike) -> DoublePair"},
	 { "AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne", _wrap_AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha_alphaSmallerMinusOne(AnalyticHestonEngine_OptimalAlpha self, Real strike) -> DoublePair"},
	 { "AnalyticHestonEngine_OptimalAlpha_numberOfEvaluations", _wrap_AnalyticHestonEngine_OptimalAlpha_numberOfEvaluations, METH_O, "AnalyticHestonEngine_OptimalAlpha_numberOfEvaluations(AnalyticHestonEngine_OptimalAlpha self) -> Size"},
	 { "AnalyticHestonEngine_OptimalAlpha_M", _wrap_AnalyticHestonEngine_OptimalAlpha_M, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha_M(AnalyticHestonEngine_OptimalAlpha self, Real k) -> Real"},
	 { "AnalyticHestonEngine_OptimalAlpha_k", _wrap_AnalyticHestonEngine_OptimalAlpha_k, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha_k(AnalyticHestonEngine_OptimalAlpha self, Real x, Integer sgn) -> Real"},
	 { "AnalyticHestonEngine_OptimalAlpha_alphaMin", _wrap_AnalyticHestonEngine_OptimalAlpha_alphaMin, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha_alphaMin(AnalyticHestonEngine_OptimalAlpha self, Real strike) -> Real"},
	 { "AnalyticHestonEngine_OptimalAlpha_alphaMax", _wrap_AnalyticHestonEngine_OptimalAlpha_alphaMax, METH_VARARGS, "AnalyticHestonEngine_OptimalAlpha_alphaMax(AnalyticHestonEngine_OptimalAlpha self, Real strike) -> Real"},
	 { "delete_AnalyticHestonEngine_OptimalAlpha", _wrap_delete_AnalyticHestonEngine_OptimalAlpha, METH_O, "delete_AnalyticHestonEngine_OptimalAlpha(AnalyticHestonEngine_OptimalAlpha self)"},
	 { "AnalyticHestonEngine_OptimalAlpha_swigregister", AnalyticHestonEngine_OptimalAlpha_swigregister, METH_O, NULL},
	 { "AnalyticHestonEngine_OptimalAlpha_swiginit", AnalyticHestonEngine_OptimalAlpha_swiginit, METH_VARARGS, NULL},
	 { "new_COSHestonEngine", _wrap_new_COSHestonEngine, METH_VARARGS, "COSHestonEngine(ext::shared_ptr< HestonModel > const & model, Real L=16, Size N=200)"},
	 { "delete_COSHestonEngine", _wrap_delete_COSHestonEngine, METH_O, "delete_COSHestonEngine(COSHestonEngine self)"},
	 { "COSHestonEngine_swigregister", COSHestonEngine_swigregister, METH_O, NULL},
	 { "COSHestonEngine_swiginit", COSHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ExponentialFittingHestonEngine", _wrap_new_ExponentialFittingHestonEngine, METH_VARARGS, "ExponentialFittingHestonEngine(ext::shared_ptr< HestonModel > const & model, ExponentialFittingHestonEngine::ControlVariate cv=ControlVariate::OptimalCV, doubleOrNull scaling=Null< Real >(), Real alpha=-0.5)"},
	 { "delete_ExponentialFittingHestonEngine", _wrap_delete_ExponentialFittingHestonEngine, METH_O, "delete_ExponentialFittingHestonEngine(ExponentialFittingHestonEngine self)"},
	 { "ExponentialFittingHestonEngine_swigregister", ExponentialFittingHestonEngine_swigregister, METH_O, NULL},
	 { "ExponentialFittingHestonEngine_swiginit", ExponentialFittingHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticPTDHestonEngine", _wrap_new_AnalyticPTDHestonEngine, METH_VARARGS, "\n"
		"AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const & model, Real relTolerance, Size maxEvaluations)\n"
		"AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const & model, Size integrationOrder=144)\n"
		"AnalyticPTDHestonEngine(ext::shared_ptr< PiecewiseTimeDependentHestonModel > const & model, AnalyticPTDHestonEngine::ComplexLogFormula cpxLog, AnalyticHestonEngine_Integration itg, Real andersenPiterbargEpsilon=1e-8)\n"
		""},
	 { "delete_AnalyticPTDHestonEngine", _wrap_delete_AnalyticPTDHestonEngine, METH_O, "delete_AnalyticPTDHestonEngine(AnalyticPTDHestonEngine self)"},
	 { "AnalyticPTDHestonEngine_swigregister", AnalyticPTDHestonEngine_swigregister, METH_O, NULL},
	 { "AnalyticPTDHestonEngine_swiginit", AnalyticPTDHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BatesModel", _wrap_new_BatesModel, METH_O, "new_BatesModel(ext::shared_ptr< BatesProcess > const & process) -> BatesModel"},
	 { "BatesModel_nu", _wrap_BatesModel_nu, METH_O, "BatesModel_nu(BatesModel self) -> Real"},
	 { "BatesModel_delta", _wrap_BatesModel_delta, METH_O, "BatesModel_delta(BatesModel self) -> Real"},
	 { "BatesModel_lambda_parameter", _wrap_BatesModel_lambda_parameter, METH_O, "BatesModel_lambda_parameter(BatesModel self) -> Real"},
	 { "delete_BatesModel", _wrap_delete_BatesModel, METH_O, "delete_BatesModel(BatesModel self)"},
	 { "BatesModel_swigregister", BatesModel_swigregister, METH_O, NULL},
	 { "BatesModel_swiginit", BatesModel_swiginit, METH_VARARGS, NULL},
	 { "new_BatesEngine", _wrap_new_BatesEngine, METH_VARARGS, "\n"
		"BatesEngine(ext::shared_ptr< BatesModel > const & model, Size integrationOrder=144)\n"
		"new_BatesEngine(ext::shared_ptr< BatesModel > const & model, Real relTolerance, Size maxEvaluations) -> BatesEngine\n"
		""},
	 { "delete_BatesEngine", _wrap_delete_BatesEngine, METH_O, "delete_BatesEngine(BatesEngine self)"},
	 { "BatesEngine_swigregister", BatesEngine_swigregister, METH_O, NULL},
	 { "BatesEngine_swiginit", BatesEngine_swiginit, METH_VARARGS, NULL},
	 { "new_IntegralEngine", _wrap_new_IntegralEngine, METH_O, "new_IntegralEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1) -> IntegralEngine"},
	 { "delete_IntegralEngine", _wrap_delete_IntegralEngine, METH_O, "delete_IntegralEngine(IntegralEngine self)"},
	 { "IntegralEngine_swigregister", IntegralEngine_swigregister, METH_O, NULL},
	 { "IntegralEngine_swiginit", IntegralEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRVanillaEngine", _wrap_new_BinomialCRRVanillaEngine, METH_VARARGS, "new_BinomialCRRVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialCRRVanillaEngine"},
	 { "delete_BinomialCRRVanillaEngine", _wrap_delete_BinomialCRRVanillaEngine, METH_O, "delete_BinomialCRRVanillaEngine(BinomialCRRVanillaEngine self)"},
	 { "BinomialCRRVanillaEngine_swigregister", BinomialCRRVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRVanillaEngine_swiginit", BinomialCRRVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRVanillaEngine", _wrap_new_BinomialJRVanillaEngine, METH_VARARGS, "new_BinomialJRVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialJRVanillaEngine"},
	 { "delete_BinomialJRVanillaEngine", _wrap_delete_BinomialJRVanillaEngine, METH_O, "delete_BinomialJRVanillaEngine(BinomialJRVanillaEngine self)"},
	 { "BinomialJRVanillaEngine_swigregister", BinomialJRVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialJRVanillaEngine_swiginit", BinomialJRVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPVanillaEngine", _wrap_new_BinomialEQPVanillaEngine, METH_VARARGS, "new_BinomialEQPVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialEQPVanillaEngine"},
	 { "delete_BinomialEQPVanillaEngine", _wrap_delete_BinomialEQPVanillaEngine, METH_O, "delete_BinomialEQPVanillaEngine(BinomialEQPVanillaEngine self)"},
	 { "BinomialEQPVanillaEngine_swigregister", BinomialEQPVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPVanillaEngine_swiginit", BinomialEQPVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisVanillaEngine", _wrap_new_BinomialTrigeorgisVanillaEngine, METH_VARARGS, "new_BinomialTrigeorgisVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialTrigeorgisVanillaEngine"},
	 { "delete_BinomialTrigeorgisVanillaEngine", _wrap_delete_BinomialTrigeorgisVanillaEngine, METH_O, "delete_BinomialTrigeorgisVanillaEngine(BinomialTrigeorgisVanillaEngine self)"},
	 { "BinomialTrigeorgisVanillaEngine_swigregister", BinomialTrigeorgisVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisVanillaEngine_swiginit", BinomialTrigeorgisVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianVanillaEngine", _wrap_new_BinomialTianVanillaEngine, METH_VARARGS, "new_BinomialTianVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialTianVanillaEngine"},
	 { "delete_BinomialTianVanillaEngine", _wrap_delete_BinomialTianVanillaEngine, METH_O, "delete_BinomialTianVanillaEngine(BinomialTianVanillaEngine self)"},
	 { "BinomialTianVanillaEngine_swigregister", BinomialTianVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialTianVanillaEngine_swiginit", BinomialTianVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRVanillaEngine", _wrap_new_BinomialLRVanillaEngine, METH_VARARGS, "new_BinomialLRVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialLRVanillaEngine"},
	 { "delete_BinomialLRVanillaEngine", _wrap_delete_BinomialLRVanillaEngine, METH_O, "delete_BinomialLRVanillaEngine(BinomialLRVanillaEngine self)"},
	 { "BinomialLRVanillaEngine_swigregister", BinomialLRVanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialLRVanillaEngine_swiginit", BinomialLRVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4VanillaEngine", _wrap_new_BinomialJ4VanillaEngine, METH_VARARGS, "new_BinomialJ4VanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialJ4VanillaEngine"},
	 { "delete_BinomialJ4VanillaEngine", _wrap_delete_BinomialJ4VanillaEngine, METH_O, "delete_BinomialJ4VanillaEngine(BinomialJ4VanillaEngine self)"},
	 { "BinomialJ4VanillaEngine_swigregister", BinomialJ4VanillaEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4VanillaEngine_swiginit", BinomialJ4VanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_LsmBasisSystem", _wrap_new_LsmBasisSystem, METH_NOARGS, "new_LsmBasisSystem() -> LsmBasisSystem"},
	 { "delete_LsmBasisSystem", _wrap_delete_LsmBasisSystem, METH_O, "delete_LsmBasisSystem(LsmBasisSystem self)"},
	 { "LsmBasisSystem_swigregister", LsmBasisSystem_swigregister, METH_O, NULL},
	 { "LsmBasisSystem_swiginit", LsmBasisSystem_swiginit, METH_VARARGS, NULL},
	 { "new_MCPREuropeanEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPREuropeanEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPREuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanEngine"},
	 { "delete_MCPREuropeanEngine", _wrap_delete_MCPREuropeanEngine, METH_O, "delete_MCPREuropeanEngine(MCPREuropeanEngine self)"},
	 { "MCPREuropeanEngine_swigregister", MCPREuropeanEngine_swigregister, METH_O, NULL},
	 { "MCPREuropeanEngine_swiginit", MCPREuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDEuropeanEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDEuropeanEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanEngine"},
	 { "delete_MCLDEuropeanEngine", _wrap_delete_MCLDEuropeanEngine, METH_O, "delete_MCLDEuropeanEngine(MCLDEuropeanEngine self)"},
	 { "MCLDEuropeanEngine_swigregister", MCLDEuropeanEngine_swigregister, METH_O, NULL},
	 { "MCLDEuropeanEngine_swiginit", MCLDEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRAmericanEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRAmericanEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull polynomOrder=2, LsmBasisSystem::PolynomialType polynomType=Monomial, int nCalibrationSamples=2048, ext::optional< bool > antitheticVariateCalibration=ext::nullopt, BigNatural seedCalibration=Null< Size >()) -> MCPRAmericanEngine"},
	 { "delete_MCPRAmericanEngine", _wrap_delete_MCPRAmericanEngine, METH_O, "delete_MCPRAmericanEngine(MCPRAmericanEngine self)"},
	 { "MCPRAmericanEngine_swigregister", MCPRAmericanEngine_swigregister, METH_O, NULL},
	 { "MCPRAmericanEngine_swiginit", MCPRAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDAmericanEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDAmericanEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull polynomOrder=2, LsmBasisSystem::PolynomialType polynomType=Monomial, int nCalibrationSamples=2048, ext::optional< bool > antitheticVariateCalibration=ext::nullopt, BigNatural seedCalibration=Null< Size >()) -> MCLDAmericanEngine"},
	 { "delete_MCLDAmericanEngine", _wrap_delete_MCLDAmericanEngine, METH_O, "delete_MCLDAmericanEngine(MCLDAmericanEngine self)"},
	 { "MCLDAmericanEngine_swigregister", MCLDAmericanEngine_swigregister, METH_O, NULL},
	 { "MCLDAmericanEngine_swiginit", MCLDAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPREuropeanHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPREuropeanHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPREuropeanHestonEngine(ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanHestonEngine"},
	 { "delete_MCPREuropeanHestonEngine", _wrap_delete_MCPREuropeanHestonEngine, METH_O, "delete_MCPREuropeanHestonEngine(MCPREuropeanHestonEngine self)"},
	 { "MCPREuropeanHestonEngine_swigregister", MCPREuropeanHestonEngine_swigregister, METH_O, NULL},
	 { "MCPREuropeanHestonEngine_swiginit", MCPREuropeanHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDEuropeanHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDEuropeanHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDEuropeanHestonEngine(ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanHestonEngine"},
	 { "delete_MCLDEuropeanHestonEngine", _wrap_delete_MCLDEuropeanHestonEngine, METH_O, "delete_MCLDEuropeanHestonEngine(MCLDEuropeanHestonEngine self)"},
	 { "MCLDEuropeanHestonEngine_swigregister", MCLDEuropeanHestonEngine_swigregister, METH_O, NULL},
	 { "MCLDEuropeanHestonEngine_swiginit", MCLDEuropeanHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDigitalEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDigitalEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRDigitalEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDigitalEngine"},
	 { "delete_MCPRDigitalEngine", _wrap_delete_MCPRDigitalEngine, METH_O, "delete_MCPRDigitalEngine(MCPRDigitalEngine self)"},
	 { "MCPRDigitalEngine_swigregister", MCPRDigitalEngine_swigregister, METH_O, NULL},
	 { "MCPRDigitalEngine_swiginit", MCPRDigitalEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDDigitalEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDDigitalEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDDigitalEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDigitalEngine"},
	 { "delete_MCLDDigitalEngine", _wrap_delete_MCLDDigitalEngine, METH_O, "delete_MCLDDigitalEngine(MCLDDigitalEngine self)"},
	 { "MCLDDigitalEngine_swigregister", MCLDDigitalEngine_swigregister, METH_O, NULL},
	 { "MCLDDigitalEngine_swiginit", MCLDDigitalEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BaroneAdesiWhaleyApproximationEngine", _wrap_new_BaroneAdesiWhaleyApproximationEngine, METH_O, "new_BaroneAdesiWhaleyApproximationEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> BaroneAdesiWhaleyApproximationEngine"},
	 { "delete_BaroneAdesiWhaleyApproximationEngine", _wrap_delete_BaroneAdesiWhaleyApproximationEngine, METH_O, "delete_BaroneAdesiWhaleyApproximationEngine(BaroneAdesiWhaleyApproximationEngine self)"},
	 { "BaroneAdesiWhaleyApproximationEngine_swigregister", BaroneAdesiWhaleyApproximationEngine_swigregister, METH_O, NULL},
	 { "BaroneAdesiWhaleyApproximationEngine_swiginit", BaroneAdesiWhaleyApproximationEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BjerksundStenslandApproximationEngine", _wrap_new_BjerksundStenslandApproximationEngine, METH_O, "new_BjerksundStenslandApproximationEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> BjerksundStenslandApproximationEngine"},
	 { "delete_BjerksundStenslandApproximationEngine", _wrap_delete_BjerksundStenslandApproximationEngine, METH_O, "delete_BjerksundStenslandApproximationEngine(BjerksundStenslandApproximationEngine self)"},
	 { "BjerksundStenslandApproximationEngine_swigregister", BjerksundStenslandApproximationEngine_swigregister, METH_O, NULL},
	 { "BjerksundStenslandApproximationEngine_swiginit", BjerksundStenslandApproximationEngine_swiginit, METH_VARARGS, NULL},
	 { "new_JuQuadraticApproximationEngine", _wrap_new_JuQuadraticApproximationEngine, METH_O, "new_JuQuadraticApproximationEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> JuQuadraticApproximationEngine"},
	 { "delete_JuQuadraticApproximationEngine", _wrap_delete_JuQuadraticApproximationEngine, METH_O, "delete_JuQuadraticApproximationEngine(JuQuadraticApproximationEngine self)"},
	 { "JuQuadraticApproximationEngine_swigregister", JuQuadraticApproximationEngine_swigregister, METH_O, NULL},
	 { "JuQuadraticApproximationEngine_swiginit", JuQuadraticApproximationEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDigitalAmericanEngine", _wrap_new_AnalyticDigitalAmericanEngine, METH_O, "new_AnalyticDigitalAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDigitalAmericanEngine"},
	 { "delete_AnalyticDigitalAmericanEngine", _wrap_delete_AnalyticDigitalAmericanEngine, METH_O, "delete_AnalyticDigitalAmericanEngine(AnalyticDigitalAmericanEngine self)"},
	 { "AnalyticDigitalAmericanEngine_swigregister", AnalyticDigitalAmericanEngine_swigregister, METH_O, NULL},
	 { "AnalyticDigitalAmericanEngine_swiginit", AnalyticDigitalAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDigitalAmericanKOEngine", _wrap_new_AnalyticDigitalAmericanKOEngine, METH_O, "new_AnalyticDigitalAmericanKOEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDigitalAmericanKOEngine"},
	 { "delete_AnalyticDigitalAmericanKOEngine", _wrap_delete_AnalyticDigitalAmericanKOEngine, METH_O, "delete_AnalyticDigitalAmericanKOEngine(AnalyticDigitalAmericanKOEngine self)"},
	 { "AnalyticDigitalAmericanKOEngine_swigregister", AnalyticDigitalAmericanKOEngine_swigregister, METH_O, NULL},
	 { "AnalyticDigitalAmericanKOEngine_swiginit", AnalyticDigitalAmericanKOEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DividendVanillaOption", _wrap_new_DividendVanillaOption, METH_VARARGS, "new_DividendVanillaOption(ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise, DateVector dividendDates, DoubleVector dividends) -> DividendVanillaOption"},
	 { "DividendVanillaOption_impliedVolatility", _wrap_DividendVanillaOption_impliedVolatility, METH_VARARGS, "DividendVanillaOption_impliedVolatility(DividendVanillaOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility"},
	 { "delete_DividendVanillaOption", _wrap_delete_DividendVanillaOption, METH_O, "delete_DividendVanillaOption(DividendVanillaOption self)"},
	 { "DividendVanillaOption_swigregister", DividendVanillaOption_swigregister, METH_O, NULL},
	 { "DividendVanillaOption_swiginit", DividendVanillaOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDividendEuropeanEngine", _wrap_new_AnalyticDividendEuropeanEngine, METH_VARARGS, "\n"
		"AnalyticDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process)\n"
		"new_AnalyticDividendEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends) -> AnalyticDividendEuropeanEngine\n"
		""},
	 { "delete_AnalyticDividendEuropeanEngine", _wrap_delete_AnalyticDividendEuropeanEngine, METH_O, "delete_AnalyticDividendEuropeanEngine(AnalyticDividendEuropeanEngine self)"},
	 { "AnalyticDividendEuropeanEngine_swigregister", AnalyticDividendEuropeanEngine_swigregister, METH_O, NULL},
	 { "AnalyticDividendEuropeanEngine_swiginit", AnalyticDividendEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_QdPlusAmericanEngine", (PyCFunction)(void(*)(void))_wrap_new_QdPlusAmericanEngine, METH_VARARGS|METH_KEYWORDS, "new_QdPlusAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process, Size interpolationPoints=8, QdPlusAmericanEngine::SolverType solverType=Halley, Real eps=1e-6, Size maxIter=Null< Size >()) -> QdPlusAmericanEngine"},
	 { "delete_QdPlusAmericanEngine", _wrap_delete_QdPlusAmericanEngine, METH_O, "delete_QdPlusAmericanEngine(QdPlusAmericanEngine self)"},
	 { "QdPlusAmericanEngine_swigregister", QdPlusAmericanEngine_swigregister, METH_O, NULL},
	 { "QdPlusAmericanEngine_swiginit", QdPlusAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "delete_QdFpIterationScheme", _wrap_delete_QdFpIterationScheme, METH_O, "delete_QdFpIterationScheme(QdFpIterationScheme self)"},
	 { "QdFpIterationScheme_swigregister", QdFpIterationScheme_swigregister, METH_O, NULL},
	 { "new_QdFpLegendreScheme", _wrap_new_QdFpLegendreScheme, METH_VARARGS, "new_QdFpLegendreScheme(Size l, Size m, Size n, Size p) -> QdFpLegendreScheme"},
	 { "delete_QdFpLegendreScheme", _wrap_delete_QdFpLegendreScheme, METH_O, "delete_QdFpLegendreScheme(QdFpLegendreScheme self)"},
	 { "QdFpLegendreScheme_swigregister", QdFpLegendreScheme_swigregister, METH_O, NULL},
	 { "QdFpLegendreScheme_swiginit", QdFpLegendreScheme_swiginit, METH_VARARGS, NULL},
	 { "new_QdFpLegendreTanhSinhScheme", _wrap_new_QdFpLegendreTanhSinhScheme, METH_VARARGS, "new_QdFpLegendreTanhSinhScheme(Size l, Size m, Size n, Real eps) -> QdFpLegendreTanhSinhScheme"},
	 { "delete_QdFpLegendreTanhSinhScheme", _wrap_delete_QdFpLegendreTanhSinhScheme, METH_O, "delete_QdFpLegendreTanhSinhScheme(QdFpLegendreTanhSinhScheme self)"},
	 { "QdFpLegendreTanhSinhScheme_swigregister", QdFpLegendreTanhSinhScheme_swigregister, METH_O, NULL},
	 { "QdFpLegendreTanhSinhScheme_swiginit", QdFpLegendreTanhSinhScheme_swiginit, METH_VARARGS, NULL},
	 { "new_QdFpTanhSinhIterationScheme", _wrap_new_QdFpTanhSinhIterationScheme, METH_VARARGS, "new_QdFpTanhSinhIterationScheme(Size m, Size n, Real eps) -> QdFpTanhSinhIterationScheme"},
	 { "delete_QdFpTanhSinhIterationScheme", _wrap_delete_QdFpTanhSinhIterationScheme, METH_O, "delete_QdFpTanhSinhIterationScheme(QdFpTanhSinhIterationScheme self)"},
	 { "QdFpTanhSinhIterationScheme_swigregister", QdFpTanhSinhIterationScheme_swigregister, METH_O, NULL},
	 { "QdFpTanhSinhIterationScheme_swiginit", QdFpTanhSinhIterationScheme_swiginit, METH_VARARGS, NULL},
	 { "new_QdFpAmericanEngine", _wrap_new_QdFpAmericanEngine, METH_VARARGS, "QdFpAmericanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > bsProcess, ext::shared_ptr< QdFpIterationScheme > iterationScheme=accurateScheme(), QdFpAmericanEngine::FixedPointEquation fpEquation=Auto)"},
	 { "QdFpAmericanEngine_fastScheme", _wrap_QdFpAmericanEngine_fastScheme, METH_NOARGS, "QdFpAmericanEngine_fastScheme() -> ext::shared_ptr< QdFpIterationScheme >"},
	 { "QdFpAmericanEngine_accurateScheme", _wrap_QdFpAmericanEngine_accurateScheme, METH_NOARGS, "QdFpAmericanEngine_accurateScheme() -> ext::shared_ptr< QdFpIterationScheme >"},
	 { "QdFpAmericanEngine_highPrecisionScheme", _wrap_QdFpAmericanEngine_highPrecisionScheme, METH_NOARGS, "QdFpAmericanEngine_highPrecisionScheme() -> ext::shared_ptr< QdFpIterationScheme >"},
	 { "delete_QdFpAmericanEngine", _wrap_delete_QdFpAmericanEngine, METH_O, "delete_QdFpAmericanEngine(QdFpAmericanEngine self)"},
	 { "QdFpAmericanEngine_swigregister", QdFpAmericanEngine_swigregister, METH_O, NULL},
	 { "QdFpAmericanEngine_swiginit", QdFpAmericanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSchemeDesc", _wrap_new_FdmSchemeDesc, METH_VARARGS, "new_FdmSchemeDesc(FdmSchemeDesc::FdmSchemeType type, Real theta, Real mu) -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_type_get", _wrap_FdmSchemeDesc_type_get, METH_O, "FdmSchemeDesc_type_get(FdmSchemeDesc self) -> FdmSchemeDesc::FdmSchemeType const"},
	 { "FdmSchemeDesc_theta_get", _wrap_FdmSchemeDesc_theta_get, METH_O, "FdmSchemeDesc_theta_get(FdmSchemeDesc self) -> Real const"},
	 { "FdmSchemeDesc_mu_get", _wrap_FdmSchemeDesc_mu_get, METH_O, "FdmSchemeDesc_mu_get(FdmSchemeDesc self) -> Real const"},
	 { "FdmSchemeDesc_Douglas", _wrap_FdmSchemeDesc_Douglas, METH_NOARGS, "FdmSchemeDesc_Douglas() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_CrankNicolson", _wrap_FdmSchemeDesc_CrankNicolson, METH_NOARGS, "FdmSchemeDesc_CrankNicolson() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_ImplicitEuler", _wrap_FdmSchemeDesc_ImplicitEuler, METH_NOARGS, "FdmSchemeDesc_ImplicitEuler() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_ExplicitEuler", _wrap_FdmSchemeDesc_ExplicitEuler, METH_NOARGS, "FdmSchemeDesc_ExplicitEuler() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_CraigSneyd", _wrap_FdmSchemeDesc_CraigSneyd, METH_NOARGS, "FdmSchemeDesc_CraigSneyd() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_ModifiedCraigSneyd", _wrap_FdmSchemeDesc_ModifiedCraigSneyd, METH_NOARGS, "FdmSchemeDesc_ModifiedCraigSneyd() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_Hundsdorfer", _wrap_FdmSchemeDesc_Hundsdorfer, METH_NOARGS, "FdmSchemeDesc_Hundsdorfer() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_ModifiedHundsdorfer", _wrap_FdmSchemeDesc_ModifiedHundsdorfer, METH_NOARGS, "FdmSchemeDesc_ModifiedHundsdorfer() -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_MethodOfLines", _wrap_FdmSchemeDesc_MethodOfLines, METH_VARARGS, "FdmSchemeDesc_MethodOfLines(Real eps=0.001, Real relInitStepSize=0.01) -> FdmSchemeDesc"},
	 { "FdmSchemeDesc_TrBDF2", _wrap_FdmSchemeDesc_TrBDF2, METH_NOARGS, "FdmSchemeDesc_TrBDF2() -> FdmSchemeDesc"},
	 { "delete_FdmSchemeDesc", _wrap_delete_FdmSchemeDesc, METH_O, "delete_FdmSchemeDesc(FdmSchemeDesc self)"},
	 { "FdmSchemeDesc_swigregister", FdmSchemeDesc_swigregister, METH_O, NULL},
	 { "FdmSchemeDesc_swiginit", FdmSchemeDesc_swiginit, METH_VARARGS, NULL},
	 { "new_FdmQuantoHelper", _wrap_new_FdmQuantoHelper, METH_VARARGS, "new_FdmQuantoHelper(ext::shared_ptr< YieldTermStructure > const & rTS, ext::shared_ptr< YieldTermStructure > const & fTS, ext::shared_ptr< BlackVolTermStructure > const & fxVolTS, Real equityFxCorrelation, Real exchRateATMlevel) -> FdmQuantoHelper"},
	 { "delete_FdmQuantoHelper", _wrap_delete_FdmQuantoHelper, METH_O, "delete_FdmQuantoHelper(FdmQuantoHelper self)"},
	 { "FdmQuantoHelper_swigregister", FdmQuantoHelper_swigregister, METH_O, NULL},
	 { "FdmQuantoHelper_swiginit", FdmQuantoHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesVanillaEngine", _wrap_new_FdBlackScholesVanillaEngine, METH_VARARGS, "\n"
		"FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot)\n"
		"FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot)\n"
		"FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot)\n"
		"FdBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, DividendSchedule dividends, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot)\n"
		""},
	 { "FdBlackScholesVanillaEngine_make", (PyCFunction)(void(*)(void))_wrap_FdBlackScholesVanillaEngine_make, METH_VARARGS|METH_KEYWORDS, "FdBlackScholesVanillaEngine_make(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends={}, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper={}, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), FdBlackScholesVanillaEngine::CashDividendModel cashDividendModel=Spot) -> ext::shared_ptr< FdBlackScholesVanillaEngine >"},
	 { "delete_FdBlackScholesVanillaEngine", _wrap_delete_FdBlackScholesVanillaEngine, METH_O, "delete_FdBlackScholesVanillaEngine(FdBlackScholesVanillaEngine self)"},
	 { "FdBlackScholesVanillaEngine_swigregister", FdBlackScholesVanillaEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesVanillaEngine_swiginit", FdBlackScholesVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesShoutEngine", _wrap_new_FdBlackScholesShoutEngine, METH_VARARGS, "\n"
		"FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())\n"
		"FdBlackScholesShoutEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())\n"
		""},
	 { "delete_FdBlackScholesShoutEngine", _wrap_delete_FdBlackScholesShoutEngine, METH_O, "delete_FdBlackScholesShoutEngine(FdBlackScholesShoutEngine self)"},
	 { "FdBlackScholesShoutEngine_swigregister", FdBlackScholesShoutEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesShoutEngine_swiginit", FdBlackScholesShoutEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdOrnsteinUhlenbeckVanillaEngine", _wrap_new_FdOrnsteinUhlenbeckVanillaEngine, METH_VARARGS, "\n"
		"FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const & arg1, ext::shared_ptr< YieldTermStructure > const & rTS, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, Real epsilon=0.0001, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())\n"
		"FdOrnsteinUhlenbeckVanillaEngine(ext::shared_ptr< OrnsteinUhlenbeckProcess > const & arg1, ext::shared_ptr< YieldTermStructure > const & rTS, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, Real epsilon=0.0001, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())\n"
		""},
	 { "delete_FdOrnsteinUhlenbeckVanillaEngine", _wrap_delete_FdOrnsteinUhlenbeckVanillaEngine, METH_O, "delete_FdOrnsteinUhlenbeckVanillaEngine(FdOrnsteinUhlenbeckVanillaEngine self)"},
	 { "FdOrnsteinUhlenbeckVanillaEngine_swigregister", FdOrnsteinUhlenbeckVanillaEngine_swigregister, METH_O, NULL},
	 { "FdOrnsteinUhlenbeckVanillaEngine_swiginit", FdOrnsteinUhlenbeckVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBatesVanillaEngine", _wrap_new_FdBatesVanillaEngine, METH_VARARGS, "\n"
		"FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())\n"
		"FdBatesVanillaEngine(ext::shared_ptr< BatesModel > const & model, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())\n"
		""},
	 { "delete_FdBatesVanillaEngine", _wrap_delete_FdBatesVanillaEngine, METH_O, "delete_FdBatesVanillaEngine(FdBatesVanillaEngine self)"},
	 { "FdBatesVanillaEngine_swigregister", FdBatesVanillaEngine_swigregister, METH_O, NULL},
	 { "FdBatesVanillaEngine_swiginit", FdBatesVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonVanillaEngine", _wrap_new_FdHestonVanillaEngine, METH_VARARGS, "\n"
		"FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		"FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		"FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const & model, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		"FdHestonVanillaEngine(ext::shared_ptr< HestonModel > const & model, DividendSchedule dividends, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		""},
	 { "FdHestonVanillaEngine_make", (PyCFunction)(void(*)(void))_wrap_FdHestonVanillaEngine_make, METH_VARARGS|METH_KEYWORDS, "FdHestonVanillaEngine_make(ext::shared_ptr< HestonModel > const & model, DividendSchedule dividends={}, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper={}, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0) -> ext::shared_ptr< FdHestonVanillaEngine >"},
	 { "delete_FdHestonVanillaEngine", _wrap_delete_FdHestonVanillaEngine, METH_O, "delete_FdHestonVanillaEngine(FdHestonVanillaEngine self)"},
	 { "FdHestonVanillaEngine_swigregister", FdHestonVanillaEngine_swigregister, METH_O, NULL},
	 { "FdHestonVanillaEngine_swiginit", FdHestonVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticCEVEngine", _wrap_new_AnalyticCEVEngine, METH_VARARGS, "new_AnalyticCEVEngine(Real f0, Real alpha, Real beta, YieldTermStructureHandle rTS) -> AnalyticCEVEngine"},
	 { "delete_AnalyticCEVEngine", _wrap_delete_AnalyticCEVEngine, METH_O, "delete_AnalyticCEVEngine(AnalyticCEVEngine self)"},
	 { "AnalyticCEVEngine_swigregister", AnalyticCEVEngine_swigregister, METH_O, NULL},
	 { "AnalyticCEVEngine_swiginit", AnalyticCEVEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdCEVVanillaEngine", _wrap_new_FdCEVVanillaEngine, METH_VARARGS, "FdCEVVanillaEngine(Real f0, Real alpha, Real beta, YieldTermStructureHandle rTS, Size tGrid=50, Size xGrid=400, Size dampingSteps=0, Real scalingFactor=1.0, Real eps=1e-4, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())"},
	 { "delete_FdCEVVanillaEngine", _wrap_delete_FdCEVVanillaEngine, METH_O, "delete_FdCEVVanillaEngine(FdCEVVanillaEngine self)"},
	 { "FdCEVVanillaEngine_swigregister", FdCEVVanillaEngine_swigregister, METH_O, NULL},
	 { "FdCEVVanillaEngine_swiginit", FdCEVVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdSabrVanillaEngine", _wrap_new_FdSabrVanillaEngine, METH_VARARGS, "FdSabrVanillaEngine(Real f0, Real alpha, Real beta, Real nu, Real rho, YieldTermStructureHandle rTS, Size tGrid=50, Size fGrid=400, Size xGrid=50, Size dampingSteps=0, Real scalingFactor=1.0, Real eps=1e-4, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())"},
	 { "delete_FdSabrVanillaEngine", _wrap_delete_FdSabrVanillaEngine, METH_O, "delete_FdSabrVanillaEngine(FdSabrVanillaEngine self)"},
	 { "FdSabrVanillaEngine_swigregister", FdSabrVanillaEngine_swigregister, METH_O, NULL},
	 { "FdSabrVanillaEngine_swiginit", FdSabrVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonHullWhiteVanillaEngine", _wrap_new_FdHestonHullWhiteVanillaEngine, METH_VARARGS, "\n"
		"FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhiteProcess > hwProcess, Real corrEquityShortRate, Size tGrid=50, Size xGrid=100, Size vGrid=40, Size rGrid=20, Size dampingSteps=0, bool controlVariate=True, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())\n"
		"FdHestonHullWhiteVanillaEngine(ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhiteProcess > hwProcess, DividendSchedule dividends, Real corrEquityShortRate, Size tGrid=50, Size xGrid=100, Size vGrid=40, Size rGrid=20, Size dampingSteps=0, bool controlVariate=True, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())\n"
		""},
	 { "delete_FdHestonHullWhiteVanillaEngine", _wrap_delete_FdHestonHullWhiteVanillaEngine, METH_O, "delete_FdHestonHullWhiteVanillaEngine(FdHestonHullWhiteVanillaEngine self)"},
	 { "FdHestonHullWhiteVanillaEngine_swigregister", FdHestonHullWhiteVanillaEngine_swigregister, METH_O, NULL},
	 { "FdHestonHullWhiteVanillaEngine_swiginit", FdHestonHullWhiteVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticHestonHullWhiteEngine", _wrap_new_AnalyticHestonHullWhiteEngine, METH_VARARGS, "\n"
		"AnalyticHestonHullWhiteEngine(ext::shared_ptr< HestonModel > const & hestonModel, ext::shared_ptr< HullWhite > hullWhiteModel, Size integrationOrder=144)\n"
		"new_AnalyticHestonHullWhiteEngine(ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhite > hullWhiteModel, Real relTolerance, Size maxEvaluations) -> AnalyticHestonHullWhiteEngine\n"
		""},
	 { "delete_AnalyticHestonHullWhiteEngine", _wrap_delete_AnalyticHestonHullWhiteEngine, METH_O, "delete_AnalyticHestonHullWhiteEngine(AnalyticHestonHullWhiteEngine self)"},
	 { "AnalyticHestonHullWhiteEngine_swigregister", AnalyticHestonHullWhiteEngine_swigregister, METH_O, NULL},
	 { "AnalyticHestonHullWhiteEngine_swiginit", AnalyticHestonHullWhiteEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticH1HWEngine", _wrap_new_AnalyticH1HWEngine, METH_VARARGS, "\n"
		"AnalyticH1HWEngine(ext::shared_ptr< HestonModel > const & hestonModel, ext::shared_ptr< HullWhite > const & hullWhiteModel, Real rhoSr, Size integrationOrder=144)\n"
		"new_AnalyticH1HWEngine(ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< HullWhite > const & hullWhiteModel, Real rhoSr, Real relTolerance, Size maxEvaluations) -> AnalyticH1HWEngine\n"
		""},
	 { "delete_AnalyticH1HWEngine", _wrap_delete_AnalyticH1HWEngine, METH_O, "delete_AnalyticH1HWEngine(AnalyticH1HWEngine self)"},
	 { "AnalyticH1HWEngine_swigregister", AnalyticH1HWEngine_swigregister, METH_O, NULL},
	 { "AnalyticH1HWEngine_swiginit", AnalyticH1HWEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardEuropeanEngine", _wrap_new_ForwardEuropeanEngine, METH_O, "new_ForwardEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1) -> ForwardEuropeanEngine"},
	 { "delete_ForwardEuropeanEngine", _wrap_delete_ForwardEuropeanEngine, METH_O, "delete_ForwardEuropeanEngine(ForwardEuropeanEngine self)"},
	 { "ForwardEuropeanEngine_swigregister", ForwardEuropeanEngine_swigregister, METH_O, NULL},
	 { "ForwardEuropeanEngine_swiginit", ForwardEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoEuropeanEngine", _wrap_new_QuantoEuropeanEngine, METH_VARARGS, "new_QuantoEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, YieldTermStructureHandle foreignRiskFreeRate, BlackVolTermStructureHandle exchangeRateVolatility, QuoteHandle correlation) -> QuantoEuropeanEngine"},
	 { "delete_QuantoEuropeanEngine", _wrap_delete_QuantoEuropeanEngine, METH_O, "delete_QuantoEuropeanEngine(QuantoEuropeanEngine self)"},
	 { "QuantoEuropeanEngine_swigregister", QuantoEuropeanEngine_swigregister, METH_O, NULL},
	 { "QuantoEuropeanEngine_swiginit", QuantoEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoForwardEuropeanEngine", _wrap_new_QuantoForwardEuropeanEngine, METH_VARARGS, "new_QuantoForwardEuropeanEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, YieldTermStructureHandle foreignRiskFreeRate, BlackVolTermStructureHandle exchangeRateVolatility, QuoteHandle correlation) -> QuantoForwardEuropeanEngine"},
	 { "delete_QuantoForwardEuropeanEngine", _wrap_delete_QuantoForwardEuropeanEngine, METH_O, "delete_QuantoForwardEuropeanEngine(QuantoForwardEuropeanEngine self)"},
	 { "QuantoForwardEuropeanEngine_swigregister", QuantoForwardEuropeanEngine_swigregister, METH_O, NULL},
	 { "QuantoForwardEuropeanEngine_swiginit", QuantoForwardEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticHestonForwardEuropeanEngine", _wrap_new_AnalyticHestonForwardEuropeanEngine, METH_VARARGS, "AnalyticHestonForwardEuropeanEngine(ext::shared_ptr< HestonProcess > const & process, Size integrationOrder=144)"},
	 { "delete_AnalyticHestonForwardEuropeanEngine", _wrap_delete_AnalyticHestonForwardEuropeanEngine, METH_O, "delete_AnalyticHestonForwardEuropeanEngine(AnalyticHestonForwardEuropeanEngine self)"},
	 { "AnalyticHestonForwardEuropeanEngine_swigregister", AnalyticHestonForwardEuropeanEngine_swigregister, METH_O, NULL},
	 { "AnalyticHestonForwardEuropeanEngine_swiginit", AnalyticHestonForwardEuropeanEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRForwardEuropeanBSEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRForwardEuropeanBSEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRForwardEuropeanBSEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRForwardEuropeanBSEngine"},
	 { "delete_MCPRForwardEuropeanBSEngine", _wrap_delete_MCPRForwardEuropeanBSEngine, METH_O, "delete_MCPRForwardEuropeanBSEngine(MCPRForwardEuropeanBSEngine self)"},
	 { "MCPRForwardEuropeanBSEngine_swigregister", MCPRForwardEuropeanBSEngine_swigregister, METH_O, NULL},
	 { "MCPRForwardEuropeanBSEngine_swiginit", MCPRForwardEuropeanBSEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDForwardEuropeanBSEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDForwardEuropeanBSEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDForwardEuropeanBSEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDForwardEuropeanBSEngine"},
	 { "delete_MCLDForwardEuropeanBSEngine", _wrap_delete_MCLDForwardEuropeanBSEngine, METH_O, "delete_MCLDForwardEuropeanBSEngine(MCLDForwardEuropeanBSEngine self)"},
	 { "MCLDForwardEuropeanBSEngine_swigregister", MCLDForwardEuropeanBSEngine_swigregister, METH_O, NULL},
	 { "MCLDForwardEuropeanBSEngine_swiginit", MCLDForwardEuropeanBSEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRForwardEuropeanHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRForwardEuropeanHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRForwardEuropeanHestonEngine(ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, bool controlVariate=False) -> MCPRForwardEuropeanHestonEngine"},
	 { "delete_MCPRForwardEuropeanHestonEngine", _wrap_delete_MCPRForwardEuropeanHestonEngine, METH_O, "delete_MCPRForwardEuropeanHestonEngine(MCPRForwardEuropeanHestonEngine self)"},
	 { "MCPRForwardEuropeanHestonEngine_swigregister", MCPRForwardEuropeanHestonEngine_swigregister, METH_O, NULL},
	 { "MCPRForwardEuropeanHestonEngine_swiginit", MCPRForwardEuropeanHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDForwardEuropeanHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDForwardEuropeanHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDForwardEuropeanHestonEngine(ext::shared_ptr< HestonProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, bool controlVariate=False) -> MCLDForwardEuropeanHestonEngine"},
	 { "delete_MCLDForwardEuropeanHestonEngine", _wrap_delete_MCLDForwardEuropeanHestonEngine, METH_O, "delete_MCLDForwardEuropeanHestonEngine(MCLDForwardEuropeanHestonEngine self)"},
	 { "MCLDForwardEuropeanHestonEngine_swigregister", MCLDForwardEuropeanHestonEngine_swigregister, METH_O, NULL},
	 { "MCLDForwardEuropeanHestonEngine_swiginit", MCLDForwardEuropeanHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCalculator", _wrap_new_BlackCalculator, METH_VARARGS, "BlackCalculator(ext::shared_ptr< StrikedTypePayoff > const & payoff, Real forward, Real stdDev, Real discount=1.0)"},
	 { "BlackCalculator_value", _wrap_BlackCalculator_value, METH_O, "BlackCalculator_value(BlackCalculator self) -> Real"},
	 { "BlackCalculator_deltaForward", _wrap_BlackCalculator_deltaForward, METH_O, "BlackCalculator_deltaForward(BlackCalculator self) -> Real"},
	 { "BlackCalculator_delta", _wrap_BlackCalculator_delta, METH_VARARGS, "BlackCalculator_delta(BlackCalculator self, Real spot) -> Real"},
	 { "BlackCalculator_elasticityForward", _wrap_BlackCalculator_elasticityForward, METH_O, "BlackCalculator_elasticityForward(BlackCalculator self) -> Real"},
	 { "BlackCalculator_elasticity", _wrap_BlackCalculator_elasticity, METH_VARARGS, "BlackCalculator_elasticity(BlackCalculator self, Real spot) -> Real"},
	 { "BlackCalculator_gammaForward", _wrap_BlackCalculator_gammaForward, METH_O, "BlackCalculator_gammaForward(BlackCalculator self) -> Real"},
	 { "BlackCalculator_gamma", _wrap_BlackCalculator_gamma, METH_VARARGS, "BlackCalculator_gamma(BlackCalculator self, Real spot) -> Real"},
	 { "BlackCalculator_theta", _wrap_BlackCalculator_theta, METH_VARARGS, "BlackCalculator_theta(BlackCalculator self, Real spot, Time maturity) -> Real"},
	 { "BlackCalculator_thetaPerDay", _wrap_BlackCalculator_thetaPerDay, METH_VARARGS, "BlackCalculator_thetaPerDay(BlackCalculator self, Real spot, Time maturity) -> Real"},
	 { "BlackCalculator_vega", _wrap_BlackCalculator_vega, METH_VARARGS, "BlackCalculator_vega(BlackCalculator self, Time maturity) -> Real"},
	 { "BlackCalculator_rho", _wrap_BlackCalculator_rho, METH_VARARGS, "BlackCalculator_rho(BlackCalculator self, Time maturity) -> Real"},
	 { "BlackCalculator_dividendRho", _wrap_BlackCalculator_dividendRho, METH_VARARGS, "BlackCalculator_dividendRho(BlackCalculator self, Time maturity) -> Real"},
	 { "BlackCalculator_itmCashProbability", _wrap_BlackCalculator_itmCashProbability, METH_O, "BlackCalculator_itmCashProbability(BlackCalculator self) -> Real"},
	 { "BlackCalculator_itmAssetProbability", _wrap_BlackCalculator_itmAssetProbability, METH_O, "BlackCalculator_itmAssetProbability(BlackCalculator self) -> Real"},
	 { "BlackCalculator_strikeSensitivity", _wrap_BlackCalculator_strikeSensitivity, METH_O, "BlackCalculator_strikeSensitivity(BlackCalculator self) -> Real"},
	 { "BlackCalculator_strikeGamma", _wrap_BlackCalculator_strikeGamma, METH_O, "BlackCalculator_strikeGamma(BlackCalculator self) -> Real"},
	 { "BlackCalculator_alpha", _wrap_BlackCalculator_alpha, METH_O, "BlackCalculator_alpha(BlackCalculator self) -> Real"},
	 { "BlackCalculator_beta", _wrap_BlackCalculator_beta, METH_O, "BlackCalculator_beta(BlackCalculator self) -> Real"},
	 { "delete_BlackCalculator", _wrap_delete_BlackCalculator, METH_O, "delete_BlackCalculator(BlackCalculator self)"},
	 { "BlackCalculator_swigregister", BlackCalculator_swigregister, METH_O, NULL},
	 { "BlackCalculator_swiginit", BlackCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_VarianceGammaEngine", _wrap_new_VarianceGammaEngine, METH_O, "new_VarianceGammaEngine(ext::shared_ptr< VarianceGammaProcess > const & process) -> VarianceGammaEngine"},
	 { "delete_VarianceGammaEngine", _wrap_delete_VarianceGammaEngine, METH_O, "delete_VarianceGammaEngine(VarianceGammaEngine self)"},
	 { "VarianceGammaEngine_swigregister", VarianceGammaEngine_swigregister, METH_O, NULL},
	 { "VarianceGammaEngine_swiginit", VarianceGammaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FFTVarianceGammaEngine", _wrap_new_FFTVarianceGammaEngine, METH_VARARGS, "FFTVarianceGammaEngine(ext::shared_ptr< VarianceGammaProcess > const & process, Real logStrikeSpacing=0.001)"},
	 { "FFTVarianceGammaEngine_precalculate", _wrap_FFTVarianceGammaEngine_precalculate, METH_VARARGS, "FFTVarianceGammaEngine_precalculate(FFTVarianceGammaEngine self, InstrumentVector optionList)"},
	 { "delete_FFTVarianceGammaEngine", _wrap_delete_FFTVarianceGammaEngine, METH_O, "delete_FFTVarianceGammaEngine(FFTVarianceGammaEngine self)"},
	 { "FFTVarianceGammaEngine_swigregister", FFTVarianceGammaEngine_swigregister, METH_O, NULL},
	 { "FFTVarianceGammaEngine_swiginit", FFTVarianceGammaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_GJRGARCHModel", _wrap_new_GJRGARCHModel, METH_O, "new_GJRGARCHModel(ext::shared_ptr< GJRGARCHProcess > const & process) -> GJRGARCHModel"},
	 { "GJRGARCHModel_omega", _wrap_GJRGARCHModel_omega, METH_O, "GJRGARCHModel_omega(GJRGARCHModel self) -> Real"},
	 { "GJRGARCHModel_alpha", _wrap_GJRGARCHModel_alpha, METH_O, "GJRGARCHModel_alpha(GJRGARCHModel self) -> Real"},
	 { "GJRGARCHModel_beta", _wrap_GJRGARCHModel_beta, METH_O, "GJRGARCHModel_beta(GJRGARCHModel self) -> Real"},
	 { "GJRGARCHModel_gamma", _wrap_GJRGARCHModel_gamma, METH_O, "GJRGARCHModel_gamma(GJRGARCHModel self) -> Real"},
	 { "GJRGARCHModel_lambda_parameter", _wrap_GJRGARCHModel_lambda_parameter, METH_O, "GJRGARCHModel_lambda_parameter(GJRGARCHModel self) -> Real"},
	 { "GJRGARCHModel_v0", _wrap_GJRGARCHModel_v0, METH_O, "GJRGARCHModel_v0(GJRGARCHModel self) -> Real"},
	 { "delete_GJRGARCHModel", _wrap_delete_GJRGARCHModel, METH_O, "delete_GJRGARCHModel(GJRGARCHModel self)"},
	 { "GJRGARCHModel_swigregister", GJRGARCHModel_swigregister, METH_O, NULL},
	 { "GJRGARCHModel_swiginit", GJRGARCHModel_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticGJRGARCHEngine", _wrap_new_AnalyticGJRGARCHEngine, METH_O, "new_AnalyticGJRGARCHEngine(ext::shared_ptr< GJRGARCHModel > const & process) -> AnalyticGJRGARCHEngine"},
	 { "delete_AnalyticGJRGARCHEngine", _wrap_delete_AnalyticGJRGARCHEngine, METH_O, "delete_AnalyticGJRGARCHEngine(AnalyticGJRGARCHEngine self)"},
	 { "AnalyticGJRGARCHEngine_swigregister", AnalyticGJRGARCHEngine_swigregister, METH_O, NULL},
	 { "AnalyticGJRGARCHEngine_swiginit", AnalyticGJRGARCHEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPREuropeanGJRGARCHEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPREuropeanGJRGARCHEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPREuropeanGJRGARCHEngine(ext::shared_ptr< GJRGARCHProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanGJRGARCHEngine"},
	 { "delete_MCPREuropeanGJRGARCHEngine", _wrap_delete_MCPREuropeanGJRGARCHEngine, METH_O, "delete_MCPREuropeanGJRGARCHEngine(MCPREuropeanGJRGARCHEngine self)"},
	 { "MCPREuropeanGJRGARCHEngine_swigregister", MCPREuropeanGJRGARCHEngine_swigregister, METH_O, NULL},
	 { "MCPREuropeanGJRGARCHEngine_swiginit", MCPREuropeanGJRGARCHEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDEuropeanGJRGARCHEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDEuropeanGJRGARCHEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDEuropeanGJRGARCHEngine(ext::shared_ptr< GJRGARCHProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanGJRGARCHEngine"},
	 { "delete_MCLDEuropeanGJRGARCHEngine", _wrap_delete_MCLDEuropeanGJRGARCHEngine, METH_O, "delete_MCLDEuropeanGJRGARCHEngine(MCLDEuropeanGJRGARCHEngine self)"},
	 { "MCLDEuropeanGJRGARCHEngine_swigregister", MCLDEuropeanGJRGARCHEngine_swigregister, METH_O, NULL},
	 { "MCLDEuropeanGJRGARCHEngine_swiginit", MCLDEuropeanGJRGARCHEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MargrabeOption", _wrap_new_MargrabeOption, METH_VARARGS, "new_MargrabeOption(Integer Q1, Integer Q2, ext::shared_ptr< Exercise > const & arg3) -> MargrabeOption"},
	 { "MargrabeOption_delta1", _wrap_MargrabeOption_delta1, METH_O, "MargrabeOption_delta1(MargrabeOption self) -> Real"},
	 { "MargrabeOption_delta2", _wrap_MargrabeOption_delta2, METH_O, "MargrabeOption_delta2(MargrabeOption self) -> Real"},
	 { "MargrabeOption_gamma1", _wrap_MargrabeOption_gamma1, METH_O, "MargrabeOption_gamma1(MargrabeOption self) -> Real"},
	 { "MargrabeOption_gamma2", _wrap_MargrabeOption_gamma2, METH_O, "MargrabeOption_gamma2(MargrabeOption self) -> Real"},
	 { "delete_MargrabeOption", _wrap_delete_MargrabeOption, METH_O, "delete_MargrabeOption(MargrabeOption self)"},
	 { "MargrabeOption_swigregister", MargrabeOption_swigregister, METH_O, NULL},
	 { "MargrabeOption_swiginit", MargrabeOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticEuropeanMargrabeEngine", _wrap_new_AnalyticEuropeanMargrabeEngine, METH_VARARGS, "new_AnalyticEuropeanMargrabeEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process1, ext::shared_ptr< GeneralizedBlackScholesProcess > process2, Real correlation) -> AnalyticEuropeanMargrabeEngine"},
	 { "delete_AnalyticEuropeanMargrabeEngine", _wrap_delete_AnalyticEuropeanMargrabeEngine, METH_O, "delete_AnalyticEuropeanMargrabeEngine(AnalyticEuropeanMargrabeEngine self)"},
	 { "AnalyticEuropeanMargrabeEngine_swigregister", AnalyticEuropeanMargrabeEngine_swigregister, METH_O, NULL},
	 { "AnalyticEuropeanMargrabeEngine_swiginit", AnalyticEuropeanMargrabeEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticAmericanMargrabeEngine", _wrap_new_AnalyticAmericanMargrabeEngine, METH_VARARGS, "new_AnalyticAmericanMargrabeEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process1, ext::shared_ptr< GeneralizedBlackScholesProcess > process2, Real correlation) -> AnalyticAmericanMargrabeEngine"},
	 { "delete_AnalyticAmericanMargrabeEngine", _wrap_delete_AnalyticAmericanMargrabeEngine, METH_O, "delete_AnalyticAmericanMargrabeEngine(AnalyticAmericanMargrabeEngine self)"},
	 { "AnalyticAmericanMargrabeEngine_swigregister", AnalyticAmericanMargrabeEngine_swigregister, METH_O, NULL},
	 { "AnalyticAmericanMargrabeEngine_swiginit", AnalyticAmericanMargrabeEngine_swiginit, METH_VARARGS, NULL},
	 { "new_CompoundOption", _wrap_new_CompoundOption, METH_VARARGS, "new_CompoundOption(ext::shared_ptr< StrikedTypePayoff > const & motherPayoff, ext::shared_ptr< Exercise > const & motherExercise, ext::shared_ptr< StrikedTypePayoff > daughterPayoff, ext::shared_ptr< Exercise > daughterExercise) -> CompoundOption"},
	 { "delete_CompoundOption", _wrap_delete_CompoundOption, METH_O, "delete_CompoundOption(CompoundOption self)"},
	 { "CompoundOption_swigregister", CompoundOption_swigregister, METH_O, NULL},
	 { "CompoundOption_swiginit", CompoundOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticCompoundOptionEngine", _wrap_new_AnalyticCompoundOptionEngine, METH_O, "new_AnalyticCompoundOptionEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process) -> AnalyticCompoundOptionEngine"},
	 { "delete_AnalyticCompoundOptionEngine", _wrap_delete_AnalyticCompoundOptionEngine, METH_O, "delete_AnalyticCompoundOptionEngine(AnalyticCompoundOptionEngine self)"},
	 { "AnalyticCompoundOptionEngine_swigregister", AnalyticCompoundOptionEngine_swigregister, METH_O, NULL},
	 { "AnalyticCompoundOptionEngine_swiginit", AnalyticCompoundOptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SimpleChooserOption", _wrap_new_SimpleChooserOption, METH_VARARGS, "new_SimpleChooserOption(Date choosingDate, Real strike, ext::shared_ptr< Exercise > const & exercise) -> SimpleChooserOption"},
	 { "delete_SimpleChooserOption", _wrap_delete_SimpleChooserOption, METH_O, "delete_SimpleChooserOption(SimpleChooserOption self)"},
	 { "SimpleChooserOption_swigregister", SimpleChooserOption_swigregister, METH_O, NULL},
	 { "SimpleChooserOption_swiginit", SimpleChooserOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticSimpleChooserEngine", _wrap_new_AnalyticSimpleChooserEngine, METH_O, "new_AnalyticSimpleChooserEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process) -> AnalyticSimpleChooserEngine"},
	 { "delete_AnalyticSimpleChooserEngine", _wrap_delete_AnalyticSimpleChooserEngine, METH_O, "delete_AnalyticSimpleChooserEngine(AnalyticSimpleChooserEngine self)"},
	 { "AnalyticSimpleChooserEngine_swigregister", AnalyticSimpleChooserEngine_swigregister, METH_O, NULL},
	 { "AnalyticSimpleChooserEngine_swiginit", AnalyticSimpleChooserEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ComplexChooserOption", _wrap_new_ComplexChooserOption, METH_VARARGS, "new_ComplexChooserOption(Date choosingDate, Real strikeCall, Real strikePut, ext::shared_ptr< Exercise > const & exerciseCall, ext::shared_ptr< Exercise > const & exercisePut) -> ComplexChooserOption"},
	 { "delete_ComplexChooserOption", _wrap_delete_ComplexChooserOption, METH_O, "delete_ComplexChooserOption(ComplexChooserOption self)"},
	 { "ComplexChooserOption_swigregister", ComplexChooserOption_swigregister, METH_O, NULL},
	 { "ComplexChooserOption_swiginit", ComplexChooserOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticComplexChooserEngine", _wrap_new_AnalyticComplexChooserEngine, METH_O, "new_AnalyticComplexChooserEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process) -> AnalyticComplexChooserEngine"},
	 { "delete_AnalyticComplexChooserEngine", _wrap_delete_AnalyticComplexChooserEngine, METH_O, "delete_AnalyticComplexChooserEngine(AnalyticComplexChooserEngine self)"},
	 { "AnalyticComplexChooserEngine_swigregister", AnalyticComplexChooserEngine_swigregister, METH_O, NULL},
	 { "AnalyticComplexChooserEngine_swiginit", AnalyticComplexChooserEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Average", _wrap_new_Average, METH_NOARGS, "new_Average() -> Average"},
	 { "delete_Average", _wrap_delete_Average, METH_O, "delete_Average(Average self)"},
	 { "Average_swigregister", Average_swigregister, METH_O, NULL},
	 { "Average_swiginit", Average_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousAveragingAsianOption", _wrap_new_ContinuousAveragingAsianOption, METH_VARARGS, "new_ContinuousAveragingAsianOption(Average::Type averageType, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousAveragingAsianOption"},
	 { "delete_ContinuousAveragingAsianOption", _wrap_delete_ContinuousAveragingAsianOption, METH_O, "delete_ContinuousAveragingAsianOption(ContinuousAveragingAsianOption self)"},
	 { "ContinuousAveragingAsianOption_swigregister", ContinuousAveragingAsianOption_swigregister, METH_O, NULL},
	 { "ContinuousAveragingAsianOption_swiginit", ContinuousAveragingAsianOption_swiginit, METH_VARARGS, NULL},
	 { "new_DiscreteAveragingAsianOption", _wrap_new_DiscreteAveragingAsianOption, METH_VARARGS, "\n"
		"DiscreteAveragingAsianOption(Average::Type averageType, Real runningAccumulator, Size pastFixings, DateVector fixingDates, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise)\n"
		"DiscreteAveragingAsianOption(Average::Type averageType, DateVector fixingDates, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise, DoubleVector allPastFixings=std::vector< Real >())\n"
		""},
	 { "DiscreteAveragingAsianOption_timeGrid", _wrap_DiscreteAveragingAsianOption_timeGrid, METH_O, "DiscreteAveragingAsianOption_timeGrid(DiscreteAveragingAsianOption self) -> TimeGrid"},
	 { "delete_DiscreteAveragingAsianOption", _wrap_delete_DiscreteAveragingAsianOption, METH_O, "delete_DiscreteAveragingAsianOption(DiscreteAveragingAsianOption self)"},
	 { "DiscreteAveragingAsianOption_swigregister", DiscreteAveragingAsianOption_swigregister, METH_O, NULL},
	 { "DiscreteAveragingAsianOption_swiginit", DiscreteAveragingAsianOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousGeometricAveragePriceAsianEngine", _wrap_new_AnalyticContinuousGeometricAveragePriceAsianEngine, METH_O, "new_AnalyticContinuousGeometricAveragePriceAsianEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousGeometricAveragePriceAsianEngine"},
	 { "delete_AnalyticContinuousGeometricAveragePriceAsianEngine", _wrap_delete_AnalyticContinuousGeometricAveragePriceAsianEngine, METH_O, "delete_AnalyticContinuousGeometricAveragePriceAsianEngine(AnalyticContinuousGeometricAveragePriceAsianEngine self)"},
	 { "AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister", AnalyticContinuousGeometricAveragePriceAsianEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit", AnalyticContinuousGeometricAveragePriceAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine", _wrap_new_AnalyticContinuousGeometricAveragePriceAsianHestonEngine, METH_VARARGS, "AnalyticContinuousGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const & process, Size summationCutoff=50, Real xiRightLimit=100.0)"},
	 { "delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine", _wrap_delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine, METH_O, "delete_AnalyticContinuousGeometricAveragePriceAsianHestonEngine(AnalyticContinuousGeometricAveragePriceAsianHestonEngine self)"},
	 { "AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swigregister", AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swiginit", AnalyticContinuousGeometricAveragePriceAsianHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDiscreteGeometricAveragePriceAsianEngine", _wrap_new_AnalyticDiscreteGeometricAveragePriceAsianEngine, METH_O, "new_AnalyticDiscreteGeometricAveragePriceAsianEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDiscreteGeometricAveragePriceAsianEngine"},
	 { "delete_AnalyticDiscreteGeometricAveragePriceAsianEngine", _wrap_delete_AnalyticDiscreteGeometricAveragePriceAsianEngine, METH_O, "delete_AnalyticDiscreteGeometricAveragePriceAsianEngine(AnalyticDiscreteGeometricAveragePriceAsianEngine self)"},
	 { "AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister", AnalyticDiscreteGeometricAveragePriceAsianEngine_swigregister, METH_O, NULL},
	 { "AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit", AnalyticDiscreteGeometricAveragePriceAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine", _wrap_new_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine, METH_VARARGS, "AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(ext::shared_ptr< HestonProcess > const & process, Real xiRightLimit=100.0)"},
	 { "delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine", _wrap_delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine, METH_O, "delete_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(AnalyticDiscreteGeometricAveragePriceAsianHestonEngine self)"},
	 { "AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swigregister", AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swigregister, METH_O, NULL},
	 { "AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swiginit", AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDiscreteGeometricAverageStrikeAsianEngine", _wrap_new_AnalyticDiscreteGeometricAverageStrikeAsianEngine, METH_O, "new_AnalyticDiscreteGeometricAverageStrikeAsianEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDiscreteGeometricAverageStrikeAsianEngine"},
	 { "delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine", _wrap_delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine, METH_O, "delete_AnalyticDiscreteGeometricAverageStrikeAsianEngine(AnalyticDiscreteGeometricAverageStrikeAsianEngine self)"},
	 { "AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister", AnalyticDiscreteGeometricAverageStrikeAsianEngine_swigregister, METH_O, NULL},
	 { "AnalyticDiscreteGeometricAverageStrikeAsianEngine_swiginit", AnalyticDiscreteGeometricAverageStrikeAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDiscreteArithmeticAPEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDiscreteArithmeticAPEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRDiscreteArithmeticAPEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDiscreteArithmeticAPEngine"},
	 { "delete_MCPRDiscreteArithmeticAPEngine", _wrap_delete_MCPRDiscreteArithmeticAPEngine, METH_O, "delete_MCPRDiscreteArithmeticAPEngine(MCPRDiscreteArithmeticAPEngine self)"},
	 { "MCPRDiscreteArithmeticAPEngine_swigregister", MCPRDiscreteArithmeticAPEngine_swigregister, METH_O, NULL},
	 { "MCPRDiscreteArithmeticAPEngine_swiginit", MCPRDiscreteArithmeticAPEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDDiscreteArithmeticAPEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDDiscreteArithmeticAPEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDDiscreteArithmeticAPEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, bool controlVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDiscreteArithmeticAPEngine"},
	 { "delete_MCLDDiscreteArithmeticAPEngine", _wrap_delete_MCLDDiscreteArithmeticAPEngine, METH_O, "delete_MCLDDiscreteArithmeticAPEngine(MCLDDiscreteArithmeticAPEngine self)"},
	 { "MCLDDiscreteArithmeticAPEngine_swigregister", MCLDDiscreteArithmeticAPEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteArithmeticAPEngine_swiginit", MCLDDiscreteArithmeticAPEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDiscreteArithmeticAPHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDiscreteArithmeticAPHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRDiscreteArithmeticAPHestonEngine(ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool controlVariate=False) -> MCPRDiscreteArithmeticAPHestonEngine"},
	 { "delete_MCPRDiscreteArithmeticAPHestonEngine", _wrap_delete_MCPRDiscreteArithmeticAPHestonEngine, METH_O, "delete_MCPRDiscreteArithmeticAPHestonEngine(MCPRDiscreteArithmeticAPHestonEngine self)"},
	 { "MCPRDiscreteArithmeticAPHestonEngine_swigregister", MCPRDiscreteArithmeticAPHestonEngine_swigregister, METH_O, NULL},
	 { "MCPRDiscreteArithmeticAPHestonEngine_swiginit", MCPRDiscreteArithmeticAPHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDDiscreteArithmeticAPHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDDiscreteArithmeticAPHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDDiscreteArithmeticAPHestonEngine(ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool controlVariate=False) -> MCLDDiscreteArithmeticAPHestonEngine"},
	 { "delete_MCLDDiscreteArithmeticAPHestonEngine", _wrap_delete_MCLDDiscreteArithmeticAPHestonEngine, METH_O, "delete_MCLDDiscreteArithmeticAPHestonEngine(MCLDDiscreteArithmeticAPHestonEngine self)"},
	 { "MCLDDiscreteArithmeticAPHestonEngine_swigregister", MCLDDiscreteArithmeticAPHestonEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteArithmeticAPHestonEngine_swiginit", MCLDDiscreteArithmeticAPHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDiscreteArithmeticASEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDiscreteArithmeticASEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRDiscreteArithmeticASEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDiscreteArithmeticASEngine"},
	 { "delete_MCPRDiscreteArithmeticASEngine", _wrap_delete_MCPRDiscreteArithmeticASEngine, METH_O, "delete_MCPRDiscreteArithmeticASEngine(MCPRDiscreteArithmeticASEngine self)"},
	 { "MCPRDiscreteArithmeticASEngine_swigregister", MCPRDiscreteArithmeticASEngine_swigregister, METH_O, NULL},
	 { "MCPRDiscreteArithmeticASEngine_swiginit", MCPRDiscreteArithmeticASEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDDiscreteArithmeticASEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDDiscreteArithmeticASEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDDiscreteArithmeticASEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDiscreteArithmeticASEngine"},
	 { "delete_MCLDDiscreteArithmeticASEngine", _wrap_delete_MCLDDiscreteArithmeticASEngine, METH_O, "delete_MCLDDiscreteArithmeticASEngine(MCLDDiscreteArithmeticASEngine self)"},
	 { "MCLDDiscreteArithmeticASEngine_swigregister", MCLDDiscreteArithmeticASEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteArithmeticASEngine_swiginit", MCLDDiscreteArithmeticASEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDiscreteGeometricAPEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDiscreteGeometricAPEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRDiscreteGeometricAPEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRDiscreteGeometricAPEngine"},
	 { "delete_MCPRDiscreteGeometricAPEngine", _wrap_delete_MCPRDiscreteGeometricAPEngine, METH_O, "delete_MCPRDiscreteGeometricAPEngine(MCPRDiscreteGeometricAPEngine self)"},
	 { "MCPRDiscreteGeometricAPEngine_swigregister", MCPRDiscreteGeometricAPEngine_swigregister, METH_O, NULL},
	 { "MCPRDiscreteGeometricAPEngine_swiginit", MCPRDiscreteGeometricAPEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDDiscreteGeometricAPEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDDiscreteGeometricAPEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDDiscreteGeometricAPEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDDiscreteGeometricAPEngine"},
	 { "delete_MCLDDiscreteGeometricAPEngine", _wrap_delete_MCLDDiscreteGeometricAPEngine, METH_O, "delete_MCLDDiscreteGeometricAPEngine(MCLDDiscreteGeometricAPEngine self)"},
	 { "MCLDDiscreteGeometricAPEngine_swigregister", MCLDDiscreteGeometricAPEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteGeometricAPEngine_swiginit", MCLDDiscreteGeometricAPEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRDiscreteGeometricAPHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRDiscreteGeometricAPHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRDiscreteGeometricAPHestonEngine(ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >()) -> MCPRDiscreteGeometricAPHestonEngine"},
	 { "delete_MCPRDiscreteGeometricAPHestonEngine", _wrap_delete_MCPRDiscreteGeometricAPHestonEngine, METH_O, "delete_MCPRDiscreteGeometricAPHestonEngine(MCPRDiscreteGeometricAPHestonEngine self)"},
	 { "MCPRDiscreteGeometricAPHestonEngine_swigregister", MCPRDiscreteGeometricAPHestonEngine_swigregister, METH_O, NULL},
	 { "MCPRDiscreteGeometricAPHestonEngine_swiginit", MCPRDiscreteGeometricAPHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDDiscreteGeometricAPHestonEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDDiscreteGeometricAPHestonEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDDiscreteGeometricAPHestonEngine(ext::shared_ptr< HestonProcess > const & process, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >()) -> MCLDDiscreteGeometricAPHestonEngine"},
	 { "delete_MCLDDiscreteGeometricAPHestonEngine", _wrap_delete_MCLDDiscreteGeometricAPHestonEngine, METH_O, "delete_MCLDDiscreteGeometricAPHestonEngine(MCLDDiscreteGeometricAPHestonEngine self)"},
	 { "MCLDDiscreteGeometricAPHestonEngine_swigregister", MCLDDiscreteGeometricAPHestonEngine_swigregister, METH_O, NULL},
	 { "MCLDDiscreteGeometricAPHestonEngine_swiginit", MCLDDiscreteGeometricAPHestonEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousArithmeticAsianLevyEngine", _wrap_new_ContinuousArithmeticAsianLevyEngine, METH_VARARGS, "new_ContinuousArithmeticAsianLevyEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, QuoteHandle runningAverage, Date startDate) -> ContinuousArithmeticAsianLevyEngine"},
	 { "delete_ContinuousArithmeticAsianLevyEngine", _wrap_delete_ContinuousArithmeticAsianLevyEngine, METH_O, "delete_ContinuousArithmeticAsianLevyEngine(ContinuousArithmeticAsianLevyEngine self)"},
	 { "ContinuousArithmeticAsianLevyEngine_swigregister", ContinuousArithmeticAsianLevyEngine_swigregister, METH_O, NULL},
	 { "ContinuousArithmeticAsianLevyEngine_swiginit", ContinuousArithmeticAsianLevyEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesAsianEngine", _wrap_new_FdBlackScholesAsianEngine, METH_VARARGS, "new_FdBlackScholesAsianEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid, Size xGrid, Size aGrid) -> FdBlackScholesAsianEngine"},
	 { "delete_FdBlackScholesAsianEngine", _wrap_delete_FdBlackScholesAsianEngine, METH_O, "delete_FdBlackScholesAsianEngine(FdBlackScholesAsianEngine self)"},
	 { "FdBlackScholesAsianEngine_swigregister", FdBlackScholesAsianEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesAsianEngine_swiginit", FdBlackScholesAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_TurnbullWakemanAsianEngine", _wrap_new_TurnbullWakemanAsianEngine, METH_O, "new_TurnbullWakemanAsianEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> TurnbullWakemanAsianEngine"},
	 { "delete_TurnbullWakemanAsianEngine", _wrap_delete_TurnbullWakemanAsianEngine, METH_O, "delete_TurnbullWakemanAsianEngine(TurnbullWakemanAsianEngine self)"},
	 { "TurnbullWakemanAsianEngine_swigregister", TurnbullWakemanAsianEngine_swigregister, METH_O, NULL},
	 { "TurnbullWakemanAsianEngine_swiginit", TurnbullWakemanAsianEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Barrier", _wrap_new_Barrier, METH_NOARGS, "new_Barrier() -> Barrier"},
	 { "delete_Barrier", _wrap_delete_Barrier, METH_O, "delete_Barrier(Barrier self)"},
	 { "Barrier_swigregister", Barrier_swigregister, METH_O, NULL},
	 { "Barrier_swiginit", Barrier_swiginit, METH_VARARGS, NULL},
	 { "new_BarrierOption", _wrap_new_BarrierOption, METH_VARARGS, "new_BarrierOption(Barrier::Type barrierType, Real barrier, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> BarrierOption"},
	 { "BarrierOption_impliedVolatility", _wrap_BarrierOption_impliedVolatility, METH_VARARGS, "\n"
		"BarrierOption_impliedVolatility(BarrierOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility\n"
		"BarrierOption_impliedVolatility(BarrierOption self, Real targetValue, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-4, Volatility maxVol=4.0) -> Volatility\n"
		""},
	 { "delete_BarrierOption", _wrap_delete_BarrierOption, METH_O, "delete_BarrierOption(BarrierOption self)"},
	 { "BarrierOption_swigregister", BarrierOption_swigregister, METH_O, NULL},
	 { "BarrierOption_swiginit", BarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoBarrierOption", _wrap_new_QuantoBarrierOption, METH_VARARGS, "new_QuantoBarrierOption(Barrier::Type barrierType, Real barrier, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoBarrierOption"},
	 { "delete_QuantoBarrierOption", _wrap_delete_QuantoBarrierOption, METH_O, "delete_QuantoBarrierOption(QuantoBarrierOption self)"},
	 { "QuantoBarrierOption_swigregister", QuantoBarrierOption_swigregister, METH_O, NULL},
	 { "QuantoBarrierOption_swiginit", QuantoBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_PartialBarrier", _wrap_new_PartialBarrier, METH_NOARGS, "new_PartialBarrier() -> PartialBarrier"},
	 { "delete_PartialBarrier", _wrap_delete_PartialBarrier, METH_O, "delete_PartialBarrier(PartialBarrier self)"},
	 { "PartialBarrier_swigregister", PartialBarrier_swigregister, METH_O, NULL},
	 { "PartialBarrier_swiginit", PartialBarrier_swiginit, METH_VARARGS, NULL},
	 { "new_PartialTimeBarrierOption", _wrap_new_PartialTimeBarrierOption, METH_VARARGS, "new_PartialTimeBarrierOption(PartialBarrier::Type barrierType, PartialBarrier::Range barrierRange, Real barrier, Real rebate, Date coverEventDate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> PartialTimeBarrierOption"},
	 { "delete_PartialTimeBarrierOption", _wrap_delete_PartialTimeBarrierOption, METH_O, "delete_PartialTimeBarrierOption(PartialTimeBarrierOption self)"},
	 { "PartialTimeBarrierOption_swigregister", PartialTimeBarrierOption_swigregister, METH_O, NULL},
	 { "PartialTimeBarrierOption_swiginit", PartialTimeBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticPartialTimeBarrierOptionEngine", _wrap_new_AnalyticPartialTimeBarrierOptionEngine, METH_O, "\n"
		"new_AnalyticPartialTimeBarrierOptionEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticPartialTimeBarrierOptionEngine\n"
		"Partial Time Barrier Option Engine\n"
		""},
	 { "delete_AnalyticPartialTimeBarrierOptionEngine", _wrap_delete_AnalyticPartialTimeBarrierOptionEngine, METH_O, "delete_AnalyticPartialTimeBarrierOptionEngine(AnalyticPartialTimeBarrierOptionEngine self)"},
	 { "AnalyticPartialTimeBarrierOptionEngine_swigregister", AnalyticPartialTimeBarrierOptionEngine_swigregister, METH_O, NULL},
	 { "AnalyticPartialTimeBarrierOptionEngine_swiginit", AnalyticPartialTimeBarrierOptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DividendBarrierOption", _wrap_new_DividendBarrierOption, METH_VARARGS, "new_DividendBarrierOption(Barrier::Type barrierType, Real barrier, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise, DateVector dividendDates, DoubleVector dividends) -> DividendBarrierOption"},
	 { "delete_DividendBarrierOption", _wrap_delete_DividendBarrierOption, METH_O, "delete_DividendBarrierOption(DividendBarrierOption self)"},
	 { "DividendBarrierOption_swigregister", DividendBarrierOption_swigregister, METH_O, NULL},
	 { "DividendBarrierOption_swiginit", DividendBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticBarrierEngine", _wrap_new_AnalyticBarrierEngine, METH_O, "new_AnalyticBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1) -> AnalyticBarrierEngine"},
	 { "delete_AnalyticBarrierEngine", _wrap_delete_AnalyticBarrierEngine, METH_O, "delete_AnalyticBarrierEngine(AnalyticBarrierEngine self)"},
	 { "AnalyticBarrierEngine_swigregister", AnalyticBarrierEngine_swigregister, METH_O, NULL},
	 { "AnalyticBarrierEngine_swiginit", AnalyticBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRBarrierEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRBarrierEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), bool isBiased=False, BigInteger seed=0) -> MCPRBarrierEngine"},
	 { "delete_MCPRBarrierEngine", _wrap_delete_MCPRBarrierEngine, METH_O, "delete_MCPRBarrierEngine(MCPRBarrierEngine self)"},
	 { "MCPRBarrierEngine_swigregister", MCPRBarrierEngine_swigregister, METH_O, NULL},
	 { "MCPRBarrierEngine_swiginit", MCPRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDBarrierEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDBarrierEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), bool isBiased=False, BigInteger seed=0) -> MCLDBarrierEngine"},
	 { "delete_MCLDBarrierEngine", _wrap_delete_MCLDBarrierEngine, METH_O, "delete_MCLDBarrierEngine(MCLDBarrierEngine self)"},
	 { "MCLDBarrierEngine_swigregister", MCLDBarrierEngine_swigregister, METH_O, NULL},
	 { "MCLDBarrierEngine_swiginit", MCLDBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoBarrierEngine", _wrap_new_QuantoBarrierEngine, METH_VARARGS, "new_QuantoBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, YieldTermStructureHandle foreignRiskFreeRate, BlackVolTermStructureHandle exchangeRateVolatility, QuoteHandle correlation) -> QuantoBarrierEngine"},
	 { "delete_QuantoBarrierEngine", _wrap_delete_QuantoBarrierEngine, METH_O, "delete_QuantoBarrierEngine(QuantoBarrierEngine self)"},
	 { "QuantoBarrierEngine_swigregister", QuantoBarrierEngine_swigregister, METH_O, NULL},
	 { "QuantoBarrierEngine_swiginit", QuantoBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesBarrierEngine", _wrap_new_FdBlackScholesBarrierEngine, METH_VARARGS, "\n"
		"FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >())\n"
		"FdBlackScholesBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >())\n"
		""},
	 { "delete_FdBlackScholesBarrierEngine", _wrap_delete_FdBlackScholesBarrierEngine, METH_O, "delete_FdBlackScholesBarrierEngine(FdBlackScholesBarrierEngine self)"},
	 { "FdBlackScholesBarrierEngine_swigregister", FdBlackScholesBarrierEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesBarrierEngine_swiginit", FdBlackScholesBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdBlackScholesRebateEngine", _wrap_new_FdBlackScholesRebateEngine, METH_VARARGS, "\n"
		"FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >())\n"
		"FdBlackScholesRebateEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >())\n"
		""},
	 { "delete_FdBlackScholesRebateEngine", _wrap_delete_FdBlackScholesRebateEngine, METH_O, "delete_FdBlackScholesRebateEngine(FdBlackScholesRebateEngine self)"},
	 { "FdBlackScholesRebateEngine_swigregister", FdBlackScholesRebateEngine_swigregister, METH_O, NULL},
	 { "FdBlackScholesRebateEngine_swiginit", FdBlackScholesRebateEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonBarrierEngine", _wrap_new_FdHestonBarrierEngine, METH_VARARGS, "\n"
		"FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		"FdHestonBarrierEngine(ext::shared_ptr< HestonModel > const & model, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		""},
	 { "delete_FdHestonBarrierEngine", _wrap_delete_FdHestonBarrierEngine, METH_O, "delete_FdHestonBarrierEngine(FdHestonBarrierEngine self)"},
	 { "FdHestonBarrierEngine_swigregister", FdHestonBarrierEngine_swigregister, METH_O, NULL},
	 { "FdHestonBarrierEngine_swiginit", FdHestonBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonRebateEngine", _wrap_new_FdHestonRebateEngine, METH_VARARGS, "\n"
		"FdHestonRebateEngine(ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		"FdHestonRebateEngine(ext::shared_ptr< HestonModel > const & model, DividendSchedule dividends, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct={}, Real const mixingFactor=1.0)\n"
		""},
	 { "delete_FdHestonRebateEngine", _wrap_delete_FdHestonRebateEngine, METH_O, "delete_FdHestonRebateEngine(FdHestonRebateEngine self)"},
	 { "FdHestonRebateEngine_swigregister", FdHestonRebateEngine_swigregister, METH_O, NULL},
	 { "FdHestonRebateEngine_swiginit", FdHestonRebateEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticBinaryBarrierEngine", _wrap_new_AnalyticBinaryBarrierEngine, METH_O, "new_AnalyticBinaryBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticBinaryBarrierEngine"},
	 { "delete_AnalyticBinaryBarrierEngine", _wrap_delete_AnalyticBinaryBarrierEngine, METH_O, "delete_AnalyticBinaryBarrierEngine(AnalyticBinaryBarrierEngine self)"},
	 { "AnalyticBinaryBarrierEngine_swigregister", AnalyticBinaryBarrierEngine_swigregister, METH_O, NULL},
	 { "AnalyticBinaryBarrierEngine_swiginit", AnalyticBinaryBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRBarrierEngine", _wrap_new_BinomialCRRBarrierEngine, METH_VARARGS, "\n"
		"BinomialCRRBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialCRRBarrierEngine", _wrap_delete_BinomialCRRBarrierEngine, METH_O, "delete_BinomialCRRBarrierEngine(BinomialCRRBarrierEngine self)"},
	 { "BinomialCRRBarrierEngine_swigregister", BinomialCRRBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRBarrierEngine_swiginit", BinomialCRRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRBarrierEngine", _wrap_new_BinomialJRBarrierEngine, METH_VARARGS, "\n"
		"BinomialJRBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialJRBarrierEngine", _wrap_delete_BinomialJRBarrierEngine, METH_O, "delete_BinomialJRBarrierEngine(BinomialJRBarrierEngine self)"},
	 { "BinomialJRBarrierEngine_swigregister", BinomialJRBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJRBarrierEngine_swiginit", BinomialJRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPBarrierEngine", _wrap_new_BinomialEQPBarrierEngine, METH_VARARGS, "\n"
		"BinomialEQPBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialEQPBarrierEngine", _wrap_delete_BinomialEQPBarrierEngine, METH_O, "delete_BinomialEQPBarrierEngine(BinomialEQPBarrierEngine self)"},
	 { "BinomialEQPBarrierEngine_swigregister", BinomialEQPBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPBarrierEngine_swiginit", BinomialEQPBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisBarrierEngine", _wrap_new_BinomialTrigeorgisBarrierEngine, METH_VARARGS, "\n"
		"BinomialTrigeorgisBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialTrigeorgisBarrierEngine", _wrap_delete_BinomialTrigeorgisBarrierEngine, METH_O, "delete_BinomialTrigeorgisBarrierEngine(BinomialTrigeorgisBarrierEngine self)"},
	 { "BinomialTrigeorgisBarrierEngine_swigregister", BinomialTrigeorgisBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisBarrierEngine_swiginit", BinomialTrigeorgisBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianBarrierEngine", _wrap_new_BinomialTianBarrierEngine, METH_VARARGS, "\n"
		"BinomialTianBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialTianBarrierEngine", _wrap_delete_BinomialTianBarrierEngine, METH_O, "delete_BinomialTianBarrierEngine(BinomialTianBarrierEngine self)"},
	 { "BinomialTianBarrierEngine_swigregister", BinomialTianBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTianBarrierEngine_swiginit", BinomialTianBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRBarrierEngine", _wrap_new_BinomialLRBarrierEngine, METH_VARARGS, "\n"
		"BinomialLRBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialLRBarrierEngine", _wrap_delete_BinomialLRBarrierEngine, METH_O, "delete_BinomialLRBarrierEngine(BinomialLRBarrierEngine self)"},
	 { "BinomialLRBarrierEngine_swigregister", BinomialLRBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialLRBarrierEngine_swiginit", BinomialLRBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4BarrierEngine", _wrap_new_BinomialJ4BarrierEngine, METH_VARARGS, "\n"
		"BinomialJ4BarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps, Size max_steps=0)\n"
		"Binomial Engine for barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Boyle-Lau adjustment for optimize steps and Derman-Kani optimization to speed\n"
		"up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		"Boyle-Lau adjustment is controlled by parameter max_steps.\n"
		"If max_steps is equal to steps Boyle-Lau is disabled.\n"
		"Il max_steps is 0 (default value), max_steps is calculated by capping it to\n"
		"5*steps when Boyle-Lau would need more than 1000 steps.\n"
		"If max_steps is specified, it would limit binomial steps to this value.\n"
		"\n"
		""},
	 { "delete_BinomialJ4BarrierEngine", _wrap_delete_BinomialJ4BarrierEngine, METH_O, "delete_BinomialJ4BarrierEngine(BinomialJ4BarrierEngine self)"},
	 { "BinomialJ4BarrierEngine_swigregister", BinomialJ4BarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4BarrierEngine_swiginit", BinomialJ4BarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VannaVolgaBarrierEngine", _wrap_new_VannaVolgaBarrierEngine, METH_VARARGS, "VannaVolgaBarrierEngine(DeltaVolQuoteHandle atmVol, DeltaVolQuoteHandle vol25Put, DeltaVolQuoteHandle vol25Call, QuoteHandle spotFX, YieldTermStructureHandle domesticTS, YieldTermStructureHandle foreignTS, bool const adaptVanDelta=False, Real const bsPriceWithSmile=0.0)"},
	 { "delete_VannaVolgaBarrierEngine", _wrap_delete_VannaVolgaBarrierEngine, METH_O, "delete_VannaVolgaBarrierEngine(VannaVolgaBarrierEngine self)"},
	 { "VannaVolgaBarrierEngine_swigregister", VannaVolgaBarrierEngine_swigregister, METH_O, NULL},
	 { "VannaVolgaBarrierEngine_swiginit", VannaVolgaBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DoubleBarrier", _wrap_new_DoubleBarrier, METH_NOARGS, "new_DoubleBarrier() -> DoubleBarrier"},
	 { "delete_DoubleBarrier", _wrap_delete_DoubleBarrier, METH_O, "delete_DoubleBarrier(DoubleBarrier self)"},
	 { "DoubleBarrier_swigregister", DoubleBarrier_swigregister, METH_O, NULL},
	 { "DoubleBarrier_swiginit", DoubleBarrier_swiginit, METH_VARARGS, NULL},
	 { "new_DoubleBarrierOption", _wrap_new_DoubleBarrierOption, METH_VARARGS, "new_DoubleBarrierOption(DoubleBarrier::Type barrierType, Real barrier_lo, Real barrier_hi, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> DoubleBarrierOption"},
	 { "delete_DoubleBarrierOption", _wrap_delete_DoubleBarrierOption, METH_O, "delete_DoubleBarrierOption(DoubleBarrierOption self)"},
	 { "DoubleBarrierOption_swigregister", DoubleBarrierOption_swigregister, METH_O, NULL},
	 { "DoubleBarrierOption_swiginit", DoubleBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_QuantoDoubleBarrierOption", _wrap_new_QuantoDoubleBarrierOption, METH_VARARGS, "new_QuantoDoubleBarrierOption(DoubleBarrier::Type barrierType, Real barrier_lo, Real barrier_hi, Real rebate, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> QuantoDoubleBarrierOption"},
	 { "QuantoDoubleBarrierOption_qvega", _wrap_QuantoDoubleBarrierOption_qvega, METH_O, "QuantoDoubleBarrierOption_qvega(QuantoDoubleBarrierOption self) -> Real"},
	 { "QuantoDoubleBarrierOption_qrho", _wrap_QuantoDoubleBarrierOption_qrho, METH_O, "QuantoDoubleBarrierOption_qrho(QuantoDoubleBarrierOption self) -> Real"},
	 { "QuantoDoubleBarrierOption_qlambda", _wrap_QuantoDoubleBarrierOption_qlambda, METH_O, "QuantoDoubleBarrierOption_qlambda(QuantoDoubleBarrierOption self) -> Real"},
	 { "delete_QuantoDoubleBarrierOption", _wrap_delete_QuantoDoubleBarrierOption, METH_O, "delete_QuantoDoubleBarrierOption(QuantoDoubleBarrierOption self)"},
	 { "QuantoDoubleBarrierOption_swigregister", QuantoDoubleBarrierOption_swigregister, METH_O, NULL},
	 { "QuantoDoubleBarrierOption_swiginit", QuantoDoubleBarrierOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDoubleBarrierEngine", _wrap_new_AnalyticDoubleBarrierEngine, METH_VARARGS, "\n"
		"AnalyticDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, int series=5)\n"
		"Double barrier engine implementing Ikeda-Kunitomo series.\n"
		""},
	 { "delete_AnalyticDoubleBarrierEngine", _wrap_delete_AnalyticDoubleBarrierEngine, METH_O, "delete_AnalyticDoubleBarrierEngine(AnalyticDoubleBarrierEngine self)"},
	 { "AnalyticDoubleBarrierEngine_swigregister", AnalyticDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "AnalyticDoubleBarrierEngine_swiginit", AnalyticDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHestonDoubleBarrierEngine", _wrap_new_FdHestonDoubleBarrierEngine, METH_VARARGS, "FdHestonDoubleBarrierEngine(ext::shared_ptr< HestonModel > const & model, Size tGrid=100, Size xGrid=100, Size vGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >(), Real const mixingFactor=1.0)"},
	 { "delete_FdHestonDoubleBarrierEngine", _wrap_delete_FdHestonDoubleBarrierEngine, METH_O, "delete_FdHestonDoubleBarrierEngine(FdHestonDoubleBarrierEngine self)"},
	 { "FdHestonDoubleBarrierEngine_swigregister", FdHestonDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "FdHestonDoubleBarrierEngine_swiginit", FdHestonDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SuoWangDoubleBarrierEngine", _wrap_new_SuoWangDoubleBarrierEngine, METH_VARARGS, "SuoWangDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, int series=5)"},
	 { "delete_SuoWangDoubleBarrierEngine", _wrap_delete_SuoWangDoubleBarrierEngine, METH_O, "delete_SuoWangDoubleBarrierEngine(SuoWangDoubleBarrierEngine self)"},
	 { "SuoWangDoubleBarrierEngine_swigregister", SuoWangDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "SuoWangDoubleBarrierEngine_swiginit", SuoWangDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VannaVolgaIKDoubleBarrierEngine", _wrap_new_VannaVolgaIKDoubleBarrierEngine, METH_VARARGS, "VannaVolgaIKDoubleBarrierEngine(DeltaVolQuoteHandle atmVol, DeltaVolQuoteHandle vol25Put, DeltaVolQuoteHandle vol25Call, QuoteHandle spotFX, YieldTermStructureHandle domesticTS, YieldTermStructureHandle foreignTS, bool const adaptVanDelta=False, Real const bsPriceWithSmile=0.0, int series=5)"},
	 { "delete_VannaVolgaIKDoubleBarrierEngine", _wrap_delete_VannaVolgaIKDoubleBarrierEngine, METH_O, "delete_VannaVolgaIKDoubleBarrierEngine(VannaVolgaIKDoubleBarrierEngine self)"},
	 { "VannaVolgaIKDoubleBarrierEngine_swigregister", VannaVolgaIKDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "VannaVolgaIKDoubleBarrierEngine_swiginit", VannaVolgaIKDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VannaVolgaWODoubleBarrierEngine", _wrap_new_VannaVolgaWODoubleBarrierEngine, METH_VARARGS, "VannaVolgaWODoubleBarrierEngine(DeltaVolQuoteHandle atmVol, DeltaVolQuoteHandle vol25Put, DeltaVolQuoteHandle vol25Call, QuoteHandle spotFX, YieldTermStructureHandle domesticTS, YieldTermStructureHandle foreignTS, bool const adaptVanDelta=False, Real const bsPriceWithSmile=0.0, int series=5)"},
	 { "delete_VannaVolgaWODoubleBarrierEngine", _wrap_delete_VannaVolgaWODoubleBarrierEngine, METH_O, "delete_VannaVolgaWODoubleBarrierEngine(VannaVolgaWODoubleBarrierEngine self)"},
	 { "VannaVolgaWODoubleBarrierEngine_swigregister", VannaVolgaWODoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "VannaVolgaWODoubleBarrierEngine_swiginit", VannaVolgaWODoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticDoubleBarrierBinaryEngine", _wrap_new_AnalyticDoubleBarrierBinaryEngine, METH_O, "new_AnalyticDoubleBarrierBinaryEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticDoubleBarrierBinaryEngine"},
	 { "delete_AnalyticDoubleBarrierBinaryEngine", _wrap_delete_AnalyticDoubleBarrierBinaryEngine, METH_O, "delete_AnalyticDoubleBarrierBinaryEngine(AnalyticDoubleBarrierBinaryEngine self)"},
	 { "AnalyticDoubleBarrierBinaryEngine_swigregister", AnalyticDoubleBarrierBinaryEngine_swigregister, METH_O, NULL},
	 { "AnalyticDoubleBarrierBinaryEngine_swiginit", AnalyticDoubleBarrierBinaryEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRDoubleBarrierEngine", _wrap_new_BinomialCRRDoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialCRRDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialCRRDoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialCRRDoubleBarrierEngine", _wrap_delete_BinomialCRRDoubleBarrierEngine, METH_O, "delete_BinomialCRRDoubleBarrierEngine(BinomialCRRDoubleBarrierEngine self)"},
	 { "BinomialCRRDoubleBarrierEngine_swigregister", BinomialCRRDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRDoubleBarrierEngine_swiginit", BinomialCRRDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRDoubleBarrierEngine", _wrap_new_BinomialJRDoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialJRDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialJRDoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialJRDoubleBarrierEngine", _wrap_delete_BinomialJRDoubleBarrierEngine, METH_O, "delete_BinomialJRDoubleBarrierEngine(BinomialJRDoubleBarrierEngine self)"},
	 { "BinomialJRDoubleBarrierEngine_swigregister", BinomialJRDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJRDoubleBarrierEngine_swiginit", BinomialJRDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPDoubleBarrierEngine", _wrap_new_BinomialEQPDoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialEQPDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialEQPDoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialEQPDoubleBarrierEngine", _wrap_delete_BinomialEQPDoubleBarrierEngine, METH_O, "delete_BinomialEQPDoubleBarrierEngine(BinomialEQPDoubleBarrierEngine self)"},
	 { "BinomialEQPDoubleBarrierEngine_swigregister", BinomialEQPDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPDoubleBarrierEngine_swiginit", BinomialEQPDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisDoubleBarrierEngine", _wrap_new_BinomialTrigeorgisDoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialTrigeorgisDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialTrigeorgisDoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialTrigeorgisDoubleBarrierEngine", _wrap_delete_BinomialTrigeorgisDoubleBarrierEngine, METH_O, "delete_BinomialTrigeorgisDoubleBarrierEngine(BinomialTrigeorgisDoubleBarrierEngine self)"},
	 { "BinomialTrigeorgisDoubleBarrierEngine_swigregister", BinomialTrigeorgisDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisDoubleBarrierEngine_swiginit", BinomialTrigeorgisDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianDoubleBarrierEngine", _wrap_new_BinomialTianDoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialTianDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialTianDoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialTianDoubleBarrierEngine", _wrap_delete_BinomialTianDoubleBarrierEngine, METH_O, "delete_BinomialTianDoubleBarrierEngine(BinomialTianDoubleBarrierEngine self)"},
	 { "BinomialTianDoubleBarrierEngine_swigregister", BinomialTianDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialTianDoubleBarrierEngine_swiginit", BinomialTianDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRDoubleBarrierEngine", _wrap_new_BinomialLRDoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialLRDoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialLRDoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialLRDoubleBarrierEngine", _wrap_delete_BinomialLRDoubleBarrierEngine, METH_O, "delete_BinomialLRDoubleBarrierEngine(BinomialLRDoubleBarrierEngine self)"},
	 { "BinomialLRDoubleBarrierEngine_swigregister", BinomialLRDoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialLRDoubleBarrierEngine_swiginit", BinomialLRDoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4DoubleBarrierEngine", _wrap_new_BinomialJ4DoubleBarrierEngine, METH_VARARGS, "\n"
		"new_BinomialJ4DoubleBarrierEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg1, Size steps) -> BinomialJ4DoubleBarrierEngine\n"
		"Binomial Engine for double barrier options.\n"
		"Features different binomial models, selected by the type parameters.\n"
		"Uses Derman-Kani optimization to speed up convergence.\n"
		"Type values:\n"
		"    crr or coxrossrubinstein:        Cox-Ross-Rubinstein model\n"
		"    jr  or jarrowrudd:               Jarrow-Rudd model\n"
		"    eqp or additiveeqpbinomialtree:  Additive EQP model\n"
		"    trigeorgis:                      Trigeorgis model\n"
		"    tian:                            Tian model\n"
		"    lr  or leisenreimer              Leisen-Reimer model\n"
		"    j4  or joshi4:                   Joshi 4th (smoothed) model\n"
		"\n"
		""},
	 { "delete_BinomialJ4DoubleBarrierEngine", _wrap_delete_BinomialJ4DoubleBarrierEngine, METH_O, "delete_BinomialJ4DoubleBarrierEngine(BinomialJ4DoubleBarrierEngine self)"},
	 { "BinomialJ4DoubleBarrierEngine_swigregister", BinomialJ4DoubleBarrierEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4DoubleBarrierEngine_swiginit", BinomialJ4DoubleBarrierEngine_swiginit, METH_VARARGS, NULL},
	 { "new_PlainVanillaPayoff", _wrap_new_PlainVanillaPayoff, METH_VARARGS, "new_PlainVanillaPayoff(Option::Type type, Real strike) -> PlainVanillaPayoff"},
	 { "delete_PlainVanillaPayoff", _wrap_delete_PlainVanillaPayoff, METH_O, "delete_PlainVanillaPayoff(PlainVanillaPayoff self)"},
	 { "PlainVanillaPayoff_swigregister", PlainVanillaPayoff_swigregister, METH_O, NULL},
	 { "PlainVanillaPayoff_swiginit", PlainVanillaPayoff_swiginit, METH_VARARGS, NULL},
	 { "as_plain_vanilla_payoff", _wrap_as_plain_vanilla_payoff, METH_O, "as_plain_vanilla_payoff(ext::shared_ptr< Payoff > const & payoff) -> ext::shared_ptr< PlainVanillaPayoff > const"},
	 { "new_PercentageStrikePayoff", _wrap_new_PercentageStrikePayoff, METH_VARARGS, "new_PercentageStrikePayoff(Option::Type type, Real moneyness) -> PercentageStrikePayoff"},
	 { "delete_PercentageStrikePayoff", _wrap_delete_PercentageStrikePayoff, METH_O, "delete_PercentageStrikePayoff(PercentageStrikePayoff self)"},
	 { "PercentageStrikePayoff_swigregister", PercentageStrikePayoff_swigregister, METH_O, NULL},
	 { "PercentageStrikePayoff_swiginit", PercentageStrikePayoff_swiginit, METH_VARARGS, NULL},
	 { "new_CashOrNothingPayoff", _wrap_new_CashOrNothingPayoff, METH_VARARGS, "new_CashOrNothingPayoff(Option::Type type, Real strike, Real payoff) -> CashOrNothingPayoff"},
	 { "delete_CashOrNothingPayoff", _wrap_delete_CashOrNothingPayoff, METH_O, "delete_CashOrNothingPayoff(CashOrNothingPayoff self)"},
	 { "CashOrNothingPayoff_swigregister", CashOrNothingPayoff_swigregister, METH_O, NULL},
	 { "CashOrNothingPayoff_swiginit", CashOrNothingPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_AssetOrNothingPayoff", _wrap_new_AssetOrNothingPayoff, METH_VARARGS, "new_AssetOrNothingPayoff(Option::Type type, Real strike) -> AssetOrNothingPayoff"},
	 { "delete_AssetOrNothingPayoff", _wrap_delete_AssetOrNothingPayoff, METH_O, "delete_AssetOrNothingPayoff(AssetOrNothingPayoff self)"},
	 { "AssetOrNothingPayoff_swigregister", AssetOrNothingPayoff_swigregister, METH_O, NULL},
	 { "AssetOrNothingPayoff_swiginit", AssetOrNothingPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_SuperSharePayoff", _wrap_new_SuperSharePayoff, METH_VARARGS, "new_SuperSharePayoff(Option::Type type, Real strike, Real increment) -> SuperSharePayoff"},
	 { "delete_SuperSharePayoff", _wrap_delete_SuperSharePayoff, METH_O, "delete_SuperSharePayoff(SuperSharePayoff self)"},
	 { "SuperSharePayoff_swigregister", SuperSharePayoff_swigregister, METH_O, NULL},
	 { "SuperSharePayoff_swiginit", SuperSharePayoff_swiginit, METH_VARARGS, NULL},
	 { "new_GapPayoff", _wrap_new_GapPayoff, METH_VARARGS, "new_GapPayoff(Option::Type type, Real strike, Real strikePayoff) -> GapPayoff"},
	 { "delete_GapPayoff", _wrap_delete_GapPayoff, METH_O, "delete_GapPayoff(GapPayoff self)"},
	 { "GapPayoff_swigregister", GapPayoff_swigregister, METH_O, NULL},
	 { "GapPayoff_swiginit", GapPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_VanillaForwardPayoff", _wrap_new_VanillaForwardPayoff, METH_VARARGS, "new_VanillaForwardPayoff(Option::Type type, Real strike) -> VanillaForwardPayoff"},
	 { "delete_VanillaForwardPayoff", _wrap_delete_VanillaForwardPayoff, METH_O, "delete_VanillaForwardPayoff(VanillaForwardPayoff self)"},
	 { "VanillaForwardPayoff_swigregister", VanillaForwardPayoff_swigregister, METH_O, NULL},
	 { "VanillaForwardPayoff_swiginit", VanillaForwardPayoff_swiginit, METH_VARARGS, NULL},
	 { "delete_BasketPayoff", _wrap_delete_BasketPayoff, METH_O, "delete_BasketPayoff(BasketPayoff self)"},
	 { "BasketPayoff_swigregister", BasketPayoff_swigregister, METH_O, NULL},
	 { "new_MinBasketPayoff", _wrap_new_MinBasketPayoff, METH_O, "new_MinBasketPayoff(ext::shared_ptr< Payoff > const p) -> MinBasketPayoff"},
	 { "delete_MinBasketPayoff", _wrap_delete_MinBasketPayoff, METH_O, "delete_MinBasketPayoff(MinBasketPayoff self)"},
	 { "MinBasketPayoff_swigregister", MinBasketPayoff_swigregister, METH_O, NULL},
	 { "MinBasketPayoff_swiginit", MinBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_MaxBasketPayoff", _wrap_new_MaxBasketPayoff, METH_O, "new_MaxBasketPayoff(ext::shared_ptr< Payoff > const p) -> MaxBasketPayoff"},
	 { "delete_MaxBasketPayoff", _wrap_delete_MaxBasketPayoff, METH_O, "delete_MaxBasketPayoff(MaxBasketPayoff self)"},
	 { "MaxBasketPayoff_swigregister", MaxBasketPayoff_swigregister, METH_O, NULL},
	 { "MaxBasketPayoff_swiginit", MaxBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_AverageBasketPayoff", _wrap_new_AverageBasketPayoff, METH_VARARGS, "\n"
		"AverageBasketPayoff(ext::shared_ptr< Payoff > const p, Array a)\n"
		"new_AverageBasketPayoff(ext::shared_ptr< Payoff > const p, Size n) -> AverageBasketPayoff\n"
		""},
	 { "delete_AverageBasketPayoff", _wrap_delete_AverageBasketPayoff, METH_O, "delete_AverageBasketPayoff(AverageBasketPayoff self)"},
	 { "AverageBasketPayoff_swigregister", AverageBasketPayoff_swigregister, METH_O, NULL},
	 { "AverageBasketPayoff_swiginit", AverageBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadBasketPayoff", _wrap_new_SpreadBasketPayoff, METH_O, "new_SpreadBasketPayoff(ext::shared_ptr< Payoff > const p) -> SpreadBasketPayoff"},
	 { "delete_SpreadBasketPayoff", _wrap_delete_SpreadBasketPayoff, METH_O, "delete_SpreadBasketPayoff(SpreadBasketPayoff self)"},
	 { "SpreadBasketPayoff_swigregister", SpreadBasketPayoff_swigregister, METH_O, NULL},
	 { "SpreadBasketPayoff_swiginit", SpreadBasketPayoff_swiginit, METH_VARARGS, NULL},
	 { "new_BasketOption", _wrap_new_BasketOption, METH_VARARGS, "new_BasketOption(ext::shared_ptr< BasketPayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> BasketOption"},
	 { "delete_BasketOption", _wrap_delete_BasketOption, METH_O, "delete_BasketOption(BasketOption self)"},
	 { "BasketOption_swigregister", BasketOption_swigregister, METH_O, NULL},
	 { "BasketOption_swiginit", BasketOption_swiginit, METH_VARARGS, NULL},
	 { "new_MCPREuropeanBasketEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPREuropeanBasketEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPREuropeanBasketEngine(ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREuropeanBasketEngine"},
	 { "delete_MCPREuropeanBasketEngine", _wrap_delete_MCPREuropeanBasketEngine, METH_O, "delete_MCPREuropeanBasketEngine(MCPREuropeanBasketEngine self)"},
	 { "MCPREuropeanBasketEngine_swigregister", MCPREuropeanBasketEngine_swigregister, METH_O, NULL},
	 { "MCPREuropeanBasketEngine_swiginit", MCPREuropeanBasketEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDEuropeanBasketEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDEuropeanBasketEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDEuropeanBasketEngine(ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEuropeanBasketEngine"},
	 { "delete_MCLDEuropeanBasketEngine", _wrap_delete_MCLDEuropeanBasketEngine, METH_O, "delete_MCLDEuropeanBasketEngine(MCLDEuropeanBasketEngine self)"},
	 { "MCLDEuropeanBasketEngine_swigregister", MCLDEuropeanBasketEngine_swigregister, METH_O, NULL},
	 { "MCLDEuropeanBasketEngine_swiginit", MCLDEuropeanBasketEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRAmericanBasketEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRAmericanBasketEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRAmericanBasketEngine(ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, Size nCalibrationSamples=Null< Size >(), Size polynomOrder=2, LsmBasisSystem::PolynomialType polynomType=Monomial) -> MCPRAmericanBasketEngine"},
	 { "delete_MCPRAmericanBasketEngine", _wrap_delete_MCPRAmericanBasketEngine, METH_O, "delete_MCPRAmericanBasketEngine(MCPRAmericanBasketEngine self)"},
	 { "MCPRAmericanBasketEngine_swigregister", MCPRAmericanBasketEngine_swigregister, METH_O, NULL},
	 { "MCPRAmericanBasketEngine_swiginit", MCPRAmericanBasketEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDAmericanBasketEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDAmericanBasketEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDAmericanBasketEngine(ext::shared_ptr< StochasticProcessArray > const & process, intOrNull timeSteps=Null< Size >(), intOrNull timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0, Size nCalibrationSamples=Null< Size >(), Size polynomOrder=2, LsmBasisSystem::PolynomialType polynomType=Monomial) -> MCLDAmericanBasketEngine"},
	 { "delete_MCLDAmericanBasketEngine", _wrap_delete_MCLDAmericanBasketEngine, METH_O, "delete_MCLDAmericanBasketEngine(MCLDAmericanBasketEngine self)"},
	 { "MCLDAmericanBasketEngine_swigregister", MCLDAmericanBasketEngine_swigregister, METH_O, NULL},
	 { "MCLDAmericanBasketEngine_swiginit", MCLDAmericanBasketEngine_swiginit, METH_VARARGS, NULL},
	 { "new_StulzEngine", _wrap_new_StulzEngine, METH_VARARGS, "new_StulzEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process2, Real correlation) -> StulzEngine"},
	 { "delete_StulzEngine", _wrap_delete_StulzEngine, METH_O, "delete_StulzEngine(StulzEngine self)"},
	 { "StulzEngine_swigregister", StulzEngine_swigregister, METH_O, NULL},
	 { "StulzEngine_swiginit", StulzEngine_swiginit, METH_VARARGS, NULL},
	 { "new_KirkEngine", _wrap_new_KirkEngine, METH_VARARGS, "new_KirkEngine(ext::shared_ptr< BlackProcess > const & process1, ext::shared_ptr< BlackProcess > const & process2, Real correlation) -> KirkEngine"},
	 { "delete_KirkEngine", _wrap_delete_KirkEngine, METH_O, "delete_KirkEngine(KirkEngine self)"},
	 { "KirkEngine_swigregister", KirkEngine_swigregister, METH_O, NULL},
	 { "KirkEngine_swiginit", KirkEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Fd2dBlackScholesVanillaEngine", _wrap_new_Fd2dBlackScholesVanillaEngine, METH_VARARGS, "Fd2dBlackScholesVanillaEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & p1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p2, Real correlation, Size xGrid=100, Size yGrid=100, Size tGrid=50, Size dampingSteps=0, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >())"},
	 { "delete_Fd2dBlackScholesVanillaEngine", _wrap_delete_Fd2dBlackScholesVanillaEngine, METH_O, "delete_Fd2dBlackScholesVanillaEngine(Fd2dBlackScholesVanillaEngine self)"},
	 { "Fd2dBlackScholesVanillaEngine_swigregister", Fd2dBlackScholesVanillaEngine_swigregister, METH_O, NULL},
	 { "Fd2dBlackScholesVanillaEngine_swiginit", Fd2dBlackScholesVanillaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_EverestOption", _wrap_new_EverestOption, METH_VARARGS, "new_EverestOption(Real notional, Rate guarantee, ext::shared_ptr< Exercise > const & exercise) -> EverestOption"},
	 { "delete_EverestOption", _wrap_delete_EverestOption, METH_O, "delete_EverestOption(EverestOption self)"},
	 { "EverestOption_swigregister", EverestOption_swigregister, METH_O, NULL},
	 { "EverestOption_swiginit", EverestOption_swiginit, METH_VARARGS, NULL},
	 { "new_MCPREverestEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPREverestEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPREverestEngine(ext::shared_ptr< StochasticProcessArray > const & process, Size timeSteps=Null< Size >(), Size timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPREverestEngine"},
	 { "delete_MCPREverestEngine", _wrap_delete_MCPREverestEngine, METH_O, "delete_MCPREverestEngine(MCPREverestEngine self)"},
	 { "MCPREverestEngine_swigregister", MCPREverestEngine_swigregister, METH_O, NULL},
	 { "MCPREverestEngine_swiginit", MCPREverestEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDEverestEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDEverestEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDEverestEngine(ext::shared_ptr< StochasticProcessArray > const & process, Size timeSteps=Null< Size >(), Size timeStepsPerYear=Null< Size >(), bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDEverestEngine"},
	 { "delete_MCLDEverestEngine", _wrap_delete_MCLDEverestEngine, METH_O, "delete_MCLDEverestEngine(MCLDEverestEngine self)"},
	 { "MCLDEverestEngine_swigregister", MCLDEverestEngine_swigregister, METH_O, NULL},
	 { "MCLDEverestEngine_swiginit", MCLDEverestEngine_swiginit, METH_VARARGS, NULL},
	 { "new_HimalayaOption", _wrap_new_HimalayaOption, METH_VARARGS, "new_HimalayaOption(DateVector fixingDates, Real strike) -> HimalayaOption"},
	 { "delete_HimalayaOption", _wrap_delete_HimalayaOption, METH_O, "delete_HimalayaOption(HimalayaOption self)"},
	 { "HimalayaOption_swigregister", HimalayaOption_swigregister, METH_O, NULL},
	 { "HimalayaOption_swiginit", HimalayaOption_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRHimalayaEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRHimalayaEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRHimalayaEngine(ext::shared_ptr< StochasticProcessArray > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRHimalayaEngine"},
	 { "delete_MCPRHimalayaEngine", _wrap_delete_MCPRHimalayaEngine, METH_O, "delete_MCPRHimalayaEngine(MCPRHimalayaEngine self)"},
	 { "MCPRHimalayaEngine_swigregister", MCPRHimalayaEngine_swigregister, METH_O, NULL},
	 { "MCPRHimalayaEngine_swiginit", MCPRHimalayaEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDHimalayaEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDHimalayaEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDHimalayaEngine(ext::shared_ptr< StochasticProcessArray > const & process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDHimalayaEngine"},
	 { "delete_MCLDHimalayaEngine", _wrap_delete_MCLDHimalayaEngine, METH_O, "delete_MCLDHimalayaEngine(MCLDHimalayaEngine self)"},
	 { "MCLDHimalayaEngine_swigregister", MCLDHimalayaEngine_swigregister, METH_O, NULL},
	 { "MCLDHimalayaEngine_swiginit", MCLDHimalayaEngine_swiginit, METH_VARARGS, NULL},
	 { "blackFormula", _wrap_blackFormula, METH_VARARGS, "blackFormula(Option::Type optionType, Real strike, Real forward, Real stdDev, Real discount=1.0, Real displacement=0.0) -> Real"},
	 { "blackFormulaImpliedStdDev", _wrap_blackFormulaImpliedStdDev, METH_VARARGS, "blackFormulaImpliedStdDev(Option::Type optionType, Real strike, Real forward, Real blackPrice, Real discount=1.0, Real displacement=0.0, Real guess=Null< Real >(), Real accuracy=1.0e-6, Natural maxIterations=100) -> Real"},
	 { "blackFormulaImpliedStdDevLiRS", _wrap_blackFormulaImpliedStdDevLiRS, METH_VARARGS, "\n"
		"blackFormulaImpliedStdDevLiRS(Option::Type optionType, Real strike, Real forward, Real blackPrice, Real discount=1.0, Real displacement=0.0, Real guess=Null< Real >(), Real omega=1.0, Real accuracy=1.0e-6, Natural maxIterations=100) -> Real\n"
		"blackFormulaImpliedStdDevLiRS(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real blackPrice, Real discount=1.0, Real displacement=0.0, Real guess=Null< Real >(), Real omega=1.0, Real accuracy=1.0e-6, Natural maxIterations=100) -> Real\n"
		""},
	 { "blackFormulaCashItmProbability", _wrap_blackFormulaCashItmProbability, METH_VARARGS, "\n"
		"blackFormulaCashItmProbability(Option::Type optionType, Real strike, Real forward, Real stdDev, Real displacement=0.0) -> Real\n"
		"blackFormulaCashItmProbability(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real stdDev, Real displacement=0.0) -> Real\n"
		""},
	 { "blackFormulaAssetItmProbability", _wrap_blackFormulaAssetItmProbability, METH_VARARGS, "\n"
		"blackFormulaAssetItmProbability(Option::Type optionType, Real strike, Real forward, Real stdDev, Real displacement=0.0) -> Real\n"
		"blackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real stdDev, Real displacement=0.0) -> Real\n"
		""},
	 { "bachelierBlackFormula", _wrap_bachelierBlackFormula, METH_VARARGS, "bachelierBlackFormula(Option::Type optionType, Real strike, Real forward, Real stdDev, Real discount=1.0) -> Real"},
	 { "bachelierBlackFormulaImpliedVol", _wrap_bachelierBlackFormulaImpliedVol, METH_VARARGS, "bachelierBlackFormulaImpliedVol(Option::Type optionType, Real strike, Real forward, Real tte, Real bachelierPrice, Real discount=1.0) -> Real"},
	 { "bachelierBlackFormulaAssetItmProbability", _wrap_bachelierBlackFormulaAssetItmProbability, METH_VARARGS, "\n"
		"bachelierBlackFormulaAssetItmProbability(Option::Type optionType, Real strike, Real forward, Real stdDev) -> Real\n"
		"bachelierBlackFormulaAssetItmProbability(ext::shared_ptr< PlainVanillaPayoff > const & payoff, Real forward, Real stdDev) -> Real\n"
		""},
	 { "new_BlackDeltaCalculator", _wrap_new_BlackDeltaCalculator, METH_VARARGS, "new_BlackDeltaCalculator(Option::Type ot, DeltaVolQuote::DeltaType dt, Real spot, DiscountFactor dDiscount, DiscountFactor fDiscount, Real stDev) -> BlackDeltaCalculator"},
	 { "BlackDeltaCalculator_deltaFromStrike", _wrap_BlackDeltaCalculator_deltaFromStrike, METH_VARARGS, "BlackDeltaCalculator_deltaFromStrike(BlackDeltaCalculator self, Real strike) -> Real"},
	 { "BlackDeltaCalculator_strikeFromDelta", _wrap_BlackDeltaCalculator_strikeFromDelta, METH_VARARGS, "BlackDeltaCalculator_strikeFromDelta(BlackDeltaCalculator self, Real delta) -> Real"},
	 { "BlackDeltaCalculator_atmStrike", _wrap_BlackDeltaCalculator_atmStrike, METH_VARARGS, "BlackDeltaCalculator_atmStrike(BlackDeltaCalculator self, DeltaVolQuote::AtmType atmT) -> Real"},
	 { "delete_BlackDeltaCalculator", _wrap_delete_BlackDeltaCalculator, METH_O, "delete_BlackDeltaCalculator(BlackDeltaCalculator self)"},
	 { "BlackDeltaCalculator_swigregister", BlackDeltaCalculator_swigregister, METH_O, NULL},
	 { "BlackDeltaCalculator_swiginit", BlackDeltaCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_TimeBasket", _wrap_new_TimeBasket, METH_VARARGS, "\n"
		"TimeBasket()\n"
		"new_TimeBasket(DateVector arg1, DoubleVector arg2) -> TimeBasket\n"
		""},
	 { "TimeBasket___len__", _wrap_TimeBasket___len__, METH_O, "TimeBasket___len__(TimeBasket self) -> Size"},
	 { "TimeBasket_rebin", _wrap_TimeBasket_rebin, METH_VARARGS, "TimeBasket_rebin(TimeBasket self, DateVector arg2) -> TimeBasket"},
	 { "TimeBasket___getitem__", _wrap_TimeBasket___getitem__, METH_VARARGS, "TimeBasket___getitem__(TimeBasket self, Date d) -> Real"},
	 { "TimeBasket___setitem__", _wrap_TimeBasket___setitem__, METH_VARARGS, "TimeBasket___setitem__(TimeBasket self, Date d, Real value)"},
	 { "TimeBasket_items", _wrap_TimeBasket_items, METH_O, "TimeBasket_items(TimeBasket self) -> PyObject *"},
	 { "TimeBasket___contains__", _wrap_TimeBasket___contains__, METH_VARARGS, "TimeBasket___contains__(TimeBasket self, Date d) -> bool"},
	 { "TimeBasket___iter__", _wrap_TimeBasket___iter__, METH_O, "TimeBasket___iter__(TimeBasket self) -> PyObject *"},
	 { "delete_TimeBasket", _wrap_delete_TimeBasket, METH_O, "delete_TimeBasket(TimeBasket self)"},
	 { "TimeBasket_swigregister", TimeBasket_swigregister, METH_O, NULL},
	 { "TimeBasket_swiginit", TimeBasket_swiginit, METH_VARARGS, NULL},
	 { "new_Swap", _wrap_new_Swap, METH_VARARGS, "\n"
		"Swap(Leg firstLeg, Leg secondLeg)\n"
		"new_Swap(LegVector legs, BoolVector payer) -> Swap\n"
		""},
	 { "Swap_numberOfLegs", _wrap_Swap_numberOfLegs, METH_O, "Swap_numberOfLegs(Swap self) -> Size"},
	 { "Swap_startDate", _wrap_Swap_startDate, METH_O, "Swap_startDate(Swap self) -> Date"},
	 { "Swap_maturityDate", _wrap_Swap_maturityDate, METH_O, "Swap_maturityDate(Swap self) -> Date"},
	 { "Swap_leg", _wrap_Swap_leg, METH_VARARGS, "Swap_leg(Swap self, Size i) -> Leg"},
	 { "Swap_legNPV", _wrap_Swap_legNPV, METH_VARARGS, "Swap_legNPV(Swap self, Size j) -> Real"},
	 { "Swap_legBPS", _wrap_Swap_legBPS, METH_VARARGS, "Swap_legBPS(Swap self, Size k) -> Real"},
	 { "Swap_startDiscounts", _wrap_Swap_startDiscounts, METH_VARARGS, "Swap_startDiscounts(Swap self, Size j) -> DiscountFactor"},
	 { "Swap_endDiscounts", _wrap_Swap_endDiscounts, METH_VARARGS, "Swap_endDiscounts(Swap self, Size j) -> DiscountFactor"},
	 { "Swap_npvDateDiscount", _wrap_Swap_npvDateDiscount, METH_O, "Swap_npvDateDiscount(Swap self) -> DiscountFactor"},
	 { "Swap_payer", _wrap_Swap_payer, METH_VARARGS, "Swap_payer(Swap self, Size j) -> bool"},
	 { "delete_Swap", _wrap_delete_Swap, METH_O, "delete_Swap(Swap self)"},
	 { "Swap_swigregister", Swap_swigregister, METH_O, NULL},
	 { "Swap_swiginit", Swap_swiginit, METH_VARARGS, NULL},
	 { "new_VanillaSwap", _wrap_new_VanillaSwap, METH_VARARGS, "VanillaSwap(Swap::Type type, Real nominal, Schedule fixedSchedule, Rate fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, ext::shared_ptr< IborIndex > const & index, Spread spread, DayCounter floatingDayCount, ext::optional< bool > withIndexedCoupons=ext::nullopt)"},
	 { "VanillaSwap_type", _wrap_VanillaSwap_type, METH_O, "VanillaSwap_type(VanillaSwap self) -> Swap::Type"},
	 { "VanillaSwap_fairRate", _wrap_VanillaSwap_fairRate, METH_O, "VanillaSwap_fairRate(VanillaSwap self) -> Rate"},
	 { "VanillaSwap_fairSpread", _wrap_VanillaSwap_fairSpread, METH_O, "VanillaSwap_fairSpread(VanillaSwap self) -> Spread"},
	 { "VanillaSwap_fixedLegBPS", _wrap_VanillaSwap_fixedLegBPS, METH_O, "VanillaSwap_fixedLegBPS(VanillaSwap self) -> Real"},
	 { "VanillaSwap_floatingLegBPS", _wrap_VanillaSwap_floatingLegBPS, METH_O, "VanillaSwap_floatingLegBPS(VanillaSwap self) -> Real"},
	 { "VanillaSwap_fixedLegNPV", _wrap_VanillaSwap_fixedLegNPV, METH_O, "VanillaSwap_fixedLegNPV(VanillaSwap self) -> Real"},
	 { "VanillaSwap_floatingLegNPV", _wrap_VanillaSwap_floatingLegNPV, METH_O, "VanillaSwap_floatingLegNPV(VanillaSwap self) -> Real"},
	 { "VanillaSwap_fixedLeg", _wrap_VanillaSwap_fixedLeg, METH_O, "VanillaSwap_fixedLeg(VanillaSwap self) -> Leg"},
	 { "VanillaSwap_floatingLeg", _wrap_VanillaSwap_floatingLeg, METH_O, "VanillaSwap_floatingLeg(VanillaSwap self) -> Leg"},
	 { "VanillaSwap_nominal", _wrap_VanillaSwap_nominal, METH_O, "VanillaSwap_nominal(VanillaSwap self) -> Real"},
	 { "VanillaSwap_fixedSchedule", _wrap_VanillaSwap_fixedSchedule, METH_O, "VanillaSwap_fixedSchedule(VanillaSwap self) -> Schedule"},
	 { "VanillaSwap_floatingSchedule", _wrap_VanillaSwap_floatingSchedule, METH_O, "VanillaSwap_floatingSchedule(VanillaSwap self) -> Schedule"},
	 { "VanillaSwap_fixedRate", _wrap_VanillaSwap_fixedRate, METH_O, "VanillaSwap_fixedRate(VanillaSwap self) -> Rate"},
	 { "VanillaSwap_spread", _wrap_VanillaSwap_spread, METH_O, "VanillaSwap_spread(VanillaSwap self) -> Spread"},
	 { "VanillaSwap_floatingDayCount", _wrap_VanillaSwap_floatingDayCount, METH_O, "VanillaSwap_floatingDayCount(VanillaSwap self) -> DayCounter"},
	 { "VanillaSwap_fixedDayCount", _wrap_VanillaSwap_fixedDayCount, METH_O, "VanillaSwap_fixedDayCount(VanillaSwap self) -> DayCounter"},
	 { "delete_VanillaSwap", _wrap_delete_VanillaSwap, METH_O, "delete_VanillaSwap(VanillaSwap self)"},
	 { "VanillaSwap_swigregister", VanillaSwap_swigregister, METH_O, NULL},
	 { "VanillaSwap_swiginit", VanillaSwap_swiginit, METH_VARARGS, NULL},
	 { "_MakeVanillaSwap_receiveFixed", _wrap__MakeVanillaSwap_receiveFixed, METH_VARARGS, "_MakeVanillaSwap_receiveFixed(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withType", _wrap__MakeVanillaSwap_withType, METH_VARARGS, "_MakeVanillaSwap_withType(_MakeVanillaSwap self, Swap::Type type) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withNominal", _wrap__MakeVanillaSwap_withNominal, METH_VARARGS, "_MakeVanillaSwap_withNominal(_MakeVanillaSwap self, Real n) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withSettlementDays", _wrap__MakeVanillaSwap_withSettlementDays, METH_VARARGS, "_MakeVanillaSwap_withSettlementDays(_MakeVanillaSwap self, Natural settlementDays) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withEffectiveDate", _wrap__MakeVanillaSwap_withEffectiveDate, METH_VARARGS, "_MakeVanillaSwap_withEffectiveDate(_MakeVanillaSwap self, Date arg2) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withTerminationDate", _wrap__MakeVanillaSwap_withTerminationDate, METH_VARARGS, "_MakeVanillaSwap_withTerminationDate(_MakeVanillaSwap self, Date arg2) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withRule", _wrap__MakeVanillaSwap_withRule, METH_VARARGS, "_MakeVanillaSwap_withRule(_MakeVanillaSwap self, DateGeneration::Rule r) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegTenor", _wrap__MakeVanillaSwap_withFixedLegTenor, METH_VARARGS, "_MakeVanillaSwap_withFixedLegTenor(_MakeVanillaSwap self, Period t) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegCalendar", _wrap__MakeVanillaSwap_withFixedLegCalendar, METH_VARARGS, "_MakeVanillaSwap_withFixedLegCalendar(_MakeVanillaSwap self, Calendar cal) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegConvention", _wrap__MakeVanillaSwap_withFixedLegConvention, METH_VARARGS, "_MakeVanillaSwap_withFixedLegConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegTerminationDateConvention", _wrap__MakeVanillaSwap_withFixedLegTerminationDateConvention, METH_VARARGS, "_MakeVanillaSwap_withFixedLegTerminationDateConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegRule", _wrap__MakeVanillaSwap_withFixedLegRule, METH_VARARGS, "_MakeVanillaSwap_withFixedLegRule(_MakeVanillaSwap self, DateGeneration::Rule r) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegEndOfMonth", _wrap__MakeVanillaSwap_withFixedLegEndOfMonth, METH_VARARGS, "_MakeVanillaSwap_withFixedLegEndOfMonth(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegFirstDate", _wrap__MakeVanillaSwap_withFixedLegFirstDate, METH_VARARGS, "_MakeVanillaSwap_withFixedLegFirstDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegNextToLastDate", _wrap__MakeVanillaSwap_withFixedLegNextToLastDate, METH_VARARGS, "_MakeVanillaSwap_withFixedLegNextToLastDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFixedLegDayCount", _wrap__MakeVanillaSwap_withFixedLegDayCount, METH_VARARGS, "_MakeVanillaSwap_withFixedLegDayCount(_MakeVanillaSwap self, DayCounter dc) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegTenor", _wrap__MakeVanillaSwap_withFloatingLegTenor, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegTenor(_MakeVanillaSwap self, Period t) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegCalendar", _wrap__MakeVanillaSwap_withFloatingLegCalendar, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegCalendar(_MakeVanillaSwap self, Calendar cal) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegConvention", _wrap__MakeVanillaSwap_withFloatingLegConvention, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegTerminationDateConvention", _wrap__MakeVanillaSwap_withFloatingLegTerminationDateConvention, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegTerminationDateConvention(_MakeVanillaSwap self, BusinessDayConvention bdc) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegRule", _wrap__MakeVanillaSwap_withFloatingLegRule, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegRule(_MakeVanillaSwap self, DateGeneration::Rule r) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegEndOfMonth", _wrap__MakeVanillaSwap_withFloatingLegEndOfMonth, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegEndOfMonth(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegFirstDate", _wrap__MakeVanillaSwap_withFloatingLegFirstDate, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegFirstDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegNextToLastDate", _wrap__MakeVanillaSwap_withFloatingLegNextToLastDate, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegNextToLastDate(_MakeVanillaSwap self, Date d) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegDayCount", _wrap__MakeVanillaSwap_withFloatingLegDayCount, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegDayCount(_MakeVanillaSwap self, DayCounter dc) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withFloatingLegSpread", _wrap__MakeVanillaSwap_withFloatingLegSpread, METH_VARARGS, "_MakeVanillaSwap_withFloatingLegSpread(_MakeVanillaSwap self, Spread sp) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withDiscountingTermStructure", _wrap__MakeVanillaSwap_withDiscountingTermStructure, METH_VARARGS, "_MakeVanillaSwap_withDiscountingTermStructure(_MakeVanillaSwap self, YieldTermStructureHandle discountCurve) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withPricingEngine", _wrap__MakeVanillaSwap_withPricingEngine, METH_VARARGS, "_MakeVanillaSwap_withPricingEngine(_MakeVanillaSwap self, ext::shared_ptr< PricingEngine > const & engine) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withIndexedCoupons", _wrap__MakeVanillaSwap_withIndexedCoupons, METH_VARARGS, "_MakeVanillaSwap_withIndexedCoupons(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_withAtParCoupons", _wrap__MakeVanillaSwap_withAtParCoupons, METH_VARARGS, "_MakeVanillaSwap_withAtParCoupons(_MakeVanillaSwap self, bool flag=True) -> _MakeVanillaSwap"},
	 { "new__MakeVanillaSwap", _wrap_new__MakeVanillaSwap, METH_VARARGS, "new__MakeVanillaSwap(Period swapTenor, ext::shared_ptr< IborIndex > const & index, Rate fixedRate, Period forwardStart) -> _MakeVanillaSwap"},
	 { "_MakeVanillaSwap_makeVanillaSwap", _wrap__MakeVanillaSwap_makeVanillaSwap, METH_O, "_MakeVanillaSwap_makeVanillaSwap(_MakeVanillaSwap self) -> ext::shared_ptr< VanillaSwap >"},
	 { "delete__MakeVanillaSwap", _wrap_delete__MakeVanillaSwap, METH_O, "delete__MakeVanillaSwap(_MakeVanillaSwap self)"},
	 { "_MakeVanillaSwap_swigregister", _MakeVanillaSwap_swigregister, METH_O, NULL},
	 { "_MakeVanillaSwap_swiginit", _MakeVanillaSwap_swiginit, METH_VARARGS, NULL},
	 { "new_NonstandardSwap", _wrap_new_NonstandardSwap, METH_VARARGS, "NonstandardSwap(Swap::Type type, DoubleVector fixedNominal, DoubleVector floatingNominal, Schedule fixedSchedule, DoubleVector fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, ext::shared_ptr< IborIndex > const & index, DoubleVector gearing, DoubleVector spread, DayCounter floatDayCount, bool const intermediateCapitalExchange=False, bool const finalCapitalExchange=False, BusinessDayConvention paymentConvention=Following)"},
	 { "NonstandardSwap_type", _wrap_NonstandardSwap_type, METH_O, "NonstandardSwap_type(NonstandardSwap self) -> Swap::Type"},
	 { "NonstandardSwap_fixedNominal", _wrap_NonstandardSwap_fixedNominal, METH_O, "NonstandardSwap_fixedNominal(NonstandardSwap self) -> DoubleVector"},
	 { "NonstandardSwap_floatingNominal", _wrap_NonstandardSwap_floatingNominal, METH_O, "NonstandardSwap_floatingNominal(NonstandardSwap self) -> DoubleVector"},
	 { "NonstandardSwap_fixedSchedule", _wrap_NonstandardSwap_fixedSchedule, METH_O, "NonstandardSwap_fixedSchedule(NonstandardSwap self) -> Schedule"},
	 { "NonstandardSwap_fixedRate", _wrap_NonstandardSwap_fixedRate, METH_O, "NonstandardSwap_fixedRate(NonstandardSwap self) -> DoubleVector"},
	 { "NonstandardSwap_fixedDayCount", _wrap_NonstandardSwap_fixedDayCount, METH_O, "NonstandardSwap_fixedDayCount(NonstandardSwap self) -> DayCounter"},
	 { "NonstandardSwap_floatingSchedule", _wrap_NonstandardSwap_floatingSchedule, METH_O, "NonstandardSwap_floatingSchedule(NonstandardSwap self) -> Schedule"},
	 { "NonstandardSwap_iborIndex", _wrap_NonstandardSwap_iborIndex, METH_O, "NonstandardSwap_iborIndex(NonstandardSwap self) -> ext::shared_ptr< IborIndex > const &"},
	 { "NonstandardSwap_spread", _wrap_NonstandardSwap_spread, METH_O, "NonstandardSwap_spread(NonstandardSwap self) -> Spread"},
	 { "NonstandardSwap_gearing", _wrap_NonstandardSwap_gearing, METH_O, "NonstandardSwap_gearing(NonstandardSwap self) -> Real"},
	 { "NonstandardSwap_spreads", _wrap_NonstandardSwap_spreads, METH_O, "NonstandardSwap_spreads(NonstandardSwap self) -> DoubleVector"},
	 { "NonstandardSwap_gearings", _wrap_NonstandardSwap_gearings, METH_O, "NonstandardSwap_gearings(NonstandardSwap self) -> DoubleVector"},
	 { "NonstandardSwap_floatingDayCount", _wrap_NonstandardSwap_floatingDayCount, METH_O, "NonstandardSwap_floatingDayCount(NonstandardSwap self) -> DayCounter"},
	 { "NonstandardSwap_paymentConvention", _wrap_NonstandardSwap_paymentConvention, METH_O, "NonstandardSwap_paymentConvention(NonstandardSwap self) -> BusinessDayConvention"},
	 { "NonstandardSwap_fixedLeg", _wrap_NonstandardSwap_fixedLeg, METH_O, "NonstandardSwap_fixedLeg(NonstandardSwap self) -> Leg"},
	 { "NonstandardSwap_floatingLeg", _wrap_NonstandardSwap_floatingLeg, METH_O, "NonstandardSwap_floatingLeg(NonstandardSwap self) -> Leg"},
	 { "delete_NonstandardSwap", _wrap_delete_NonstandardSwap, METH_O, "delete_NonstandardSwap(NonstandardSwap self)"},
	 { "NonstandardSwap_swigregister", NonstandardSwap_swigregister, METH_O, NULL},
	 { "NonstandardSwap_swiginit", NonstandardSwap_swiginit, METH_VARARGS, NULL},
	 { "new_DiscountingSwapEngine", _wrap_new_DiscountingSwapEngine, METH_VARARGS, "\n"
		"DiscountingSwapEngine(YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows, Date settlementDate=Date(), Date npvDate=Date())\n"
		"DiscountingSwapEngine(YieldTermStructureHandle discountCurve, Date settlementDate=Date(), Date npvDate=Date())\n"
		""},
	 { "delete_DiscountingSwapEngine", _wrap_delete_DiscountingSwapEngine, METH_O, "delete_DiscountingSwapEngine(DiscountingSwapEngine self)"},
	 { "DiscountingSwapEngine_swigregister", DiscountingSwapEngine_swigregister, METH_O, NULL},
	 { "DiscountingSwapEngine_swiginit", DiscountingSwapEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AssetSwap", (PyCFunction)(void(*)(void))_wrap_new_AssetSwap, METH_VARARGS|METH_KEYWORDS, "new_AssetSwap(bool payFixedRate, ext::shared_ptr< Bond > const & bond, Real bondCleanPrice, ext::shared_ptr< IborIndex > const & index, Spread spread, Schedule floatSchedule=Schedule(), DayCounter floatingDayCount=DayCounter(), bool parAssetSwap=True) -> AssetSwap"},
	 { "AssetSwap_fairCleanPrice", _wrap_AssetSwap_fairCleanPrice, METH_O, "AssetSwap_fairCleanPrice(AssetSwap self) -> Real"},
	 { "AssetSwap_fairSpread", _wrap_AssetSwap_fairSpread, METH_O, "AssetSwap_fairSpread(AssetSwap self) -> Spread"},
	 { "delete_AssetSwap", _wrap_delete_AssetSwap, METH_O, "delete_AssetSwap(AssetSwap self)"},
	 { "AssetSwap_swigregister", AssetSwap_swigregister, METH_O, NULL},
	 { "AssetSwap_swiginit", AssetSwap_swiginit, METH_VARARGS, NULL},
	 { "new_FloatFloatSwap", _wrap_new_FloatFloatSwap, METH_VARARGS, "FloatFloatSwap(Swap::Type type, DoubleVector nominal1, DoubleVector nominal2, Schedule schedule1, ext::shared_ptr< InterestRateIndex > const & index1, DayCounter dayCount1, Schedule schedule2, ext::shared_ptr< InterestRateIndex > const & index2, DayCounter dayCount2, bool const intermediateCapitalExchange=False, bool const finalCapitalExchange=False, DoubleVector gearing1=std::vector< Real >(), DoubleVector spread1=std::vector< Real >(), DoubleVector cappedRate1=std::vector< Real >(), DoubleVector flooredRate1=std::vector< Real >(), DoubleVector gearing2=std::vector< Real >(), DoubleVector spread2=std::vector< Real >(), DoubleVector cappedRate2=std::vector< Real >(), DoubleVector flooredRate2=std::vector< Real >(), BusinessDayConvention paymentConvention1=Following, BusinessDayConvention paymentConvention2=Following)"},
	 { "delete_FloatFloatSwap", _wrap_delete_FloatFloatSwap, METH_O, "delete_FloatFloatSwap(FloatFloatSwap self)"},
	 { "FloatFloatSwap_swigregister", FloatFloatSwap_swigregister, METH_O, NULL},
	 { "FloatFloatSwap_swiginit", FloatFloatSwap_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexedSwap", _wrap_new_OvernightIndexedSwap, METH_VARARGS, "\n"
		"OvernightIndexedSwap(Swap::Type type, Real nominal, Schedule schedule, Rate fixedRate, DayCounter fixedDC, ext::shared_ptr< OvernightIndex > const & index, Spread spread=0.0, Integer paymentLag=0, BusinessDayConvention paymentAdjustment=Following, Calendar paymentCalendar=Calendar(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound)\n"
		"OvernightIndexedSwap(Swap::Type type, DoubleVector nominals, Schedule schedule, Rate fixedRate, DayCounter fixedDC, ext::shared_ptr< OvernightIndex > const & index, Spread spread=0.0, Integer paymentLag=0, BusinessDayConvention paymentAdjustment=Following, Calendar paymentCalendar=Calendar(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound)\n"
		"OvernightIndexedSwap(Swap::Type type, DoubleVector fixedNominals, Schedule fixedSchedule, Rate fixedRate, DayCounter fixedDC, DoubleVector overnightNominals, Schedule overnightSchedule, ext::shared_ptr< OvernightIndex > const & overnightIndex, Spread spread=0.0, Integer paymentLag=0, BusinessDayConvention paymentAdjustment=Following, Calendar paymentCalendar=Calendar(), bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound)\n"
		""},
	 { "OvernightIndexedSwap_fixedLegBPS", _wrap_OvernightIndexedSwap_fixedLegBPS, METH_O, "OvernightIndexedSwap_fixedLegBPS(OvernightIndexedSwap self) -> Rate"},
	 { "OvernightIndexedSwap_fixedLegNPV", _wrap_OvernightIndexedSwap_fixedLegNPV, METH_O, "OvernightIndexedSwap_fixedLegNPV(OvernightIndexedSwap self) -> Real"},
	 { "OvernightIndexedSwap_fairRate", _wrap_OvernightIndexedSwap_fairRate, METH_O, "OvernightIndexedSwap_fairRate(OvernightIndexedSwap self) -> Real"},
	 { "OvernightIndexedSwap_overnightLegBPS", _wrap_OvernightIndexedSwap_overnightLegBPS, METH_O, "OvernightIndexedSwap_overnightLegBPS(OvernightIndexedSwap self) -> Real"},
	 { "OvernightIndexedSwap_overnightLegNPV", _wrap_OvernightIndexedSwap_overnightLegNPV, METH_O, "OvernightIndexedSwap_overnightLegNPV(OvernightIndexedSwap self) -> Real"},
	 { "OvernightIndexedSwap_fairSpread", _wrap_OvernightIndexedSwap_fairSpread, METH_O, "OvernightIndexedSwap_fairSpread(OvernightIndexedSwap self) -> Spread"},
	 { "OvernightIndexedSwap_type", _wrap_OvernightIndexedSwap_type, METH_O, "OvernightIndexedSwap_type(OvernightIndexedSwap self) -> Swap::Type"},
	 { "OvernightIndexedSwap_nominal", _wrap_OvernightIndexedSwap_nominal, METH_O, "OvernightIndexedSwap_nominal(OvernightIndexedSwap self) -> Real"},
	 { "OvernightIndexedSwap_nominals", _wrap_OvernightIndexedSwap_nominals, METH_O, "OvernightIndexedSwap_nominals(OvernightIndexedSwap self) -> DoubleVector"},
	 { "OvernightIndexedSwap_paymentFrequency", _wrap_OvernightIndexedSwap_paymentFrequency, METH_O, "OvernightIndexedSwap_paymentFrequency(OvernightIndexedSwap self) -> Frequency"},
	 { "OvernightIndexedSwap_fixedRate", _wrap_OvernightIndexedSwap_fixedRate, METH_O, "OvernightIndexedSwap_fixedRate(OvernightIndexedSwap self) -> Rate"},
	 { "OvernightIndexedSwap_fixedDayCount", _wrap_OvernightIndexedSwap_fixedDayCount, METH_O, "OvernightIndexedSwap_fixedDayCount(OvernightIndexedSwap self) -> DayCounter"},
	 { "OvernightIndexedSwap_overnightIndex", _wrap_OvernightIndexedSwap_overnightIndex, METH_O, "OvernightIndexedSwap_overnightIndex(OvernightIndexedSwap self) -> ext::shared_ptr< OvernightIndex >"},
	 { "OvernightIndexedSwap_spread", _wrap_OvernightIndexedSwap_spread, METH_O, "OvernightIndexedSwap_spread(OvernightIndexedSwap self) -> Spread"},
	 { "OvernightIndexedSwap_fixedLeg", _wrap_OvernightIndexedSwap_fixedLeg, METH_O, "OvernightIndexedSwap_fixedLeg(OvernightIndexedSwap self) -> Leg"},
	 { "OvernightIndexedSwap_overnightLeg", _wrap_OvernightIndexedSwap_overnightLeg, METH_O, "OvernightIndexedSwap_overnightLeg(OvernightIndexedSwap self) -> Leg"},
	 { "OvernightIndexedSwap_averagingMethod", _wrap_OvernightIndexedSwap_averagingMethod, METH_O, "OvernightIndexedSwap_averagingMethod(OvernightIndexedSwap self) -> RateAveraging::Type"},
	 { "delete_OvernightIndexedSwap", _wrap_delete_OvernightIndexedSwap, METH_O, "delete_OvernightIndexedSwap(OvernightIndexedSwap self)"},
	 { "OvernightIndexedSwap_swigregister", OvernightIndexedSwap_swigregister, METH_O, NULL},
	 { "OvernightIndexedSwap_swiginit", OvernightIndexedSwap_swiginit, METH_VARARGS, NULL},
	 { "new__MakeOIS", _wrap_new__MakeOIS, METH_VARARGS, "_MakeOIS(Period swapTenor, ext::shared_ptr< OvernightIndex > const & overnightIndex, Rate fixedRate=Null< Rate >(), Period fwdStart=0*Days)"},
	 { "_MakeOIS_makeOIS", _wrap__MakeOIS_makeOIS, METH_O, "_MakeOIS_makeOIS(_MakeOIS self) -> ext::shared_ptr< OvernightIndexedSwap >"},
	 { "_MakeOIS_receiveFixed", _wrap__MakeOIS_receiveFixed, METH_VARARGS, "_MakeOIS_receiveFixed(_MakeOIS self, bool flag=True) -> _MakeOIS"},
	 { "_MakeOIS_withType", _wrap__MakeOIS_withType, METH_VARARGS, "_MakeOIS_withType(_MakeOIS self, Swap::Type type) -> _MakeOIS"},
	 { "_MakeOIS_withNominal", _wrap__MakeOIS_withNominal, METH_VARARGS, "_MakeOIS_withNominal(_MakeOIS self, Real n) -> _MakeOIS"},
	 { "_MakeOIS_withSettlementDays", _wrap__MakeOIS_withSettlementDays, METH_VARARGS, "_MakeOIS_withSettlementDays(_MakeOIS self, Natural settlementDays) -> _MakeOIS"},
	 { "_MakeOIS_withEffectiveDate", _wrap__MakeOIS_withEffectiveDate, METH_VARARGS, "_MakeOIS_withEffectiveDate(_MakeOIS self, Date arg2) -> _MakeOIS"},
	 { "_MakeOIS_withTerminationDate", _wrap__MakeOIS_withTerminationDate, METH_VARARGS, "_MakeOIS_withTerminationDate(_MakeOIS self, Date arg2) -> _MakeOIS"},
	 { "_MakeOIS_withRule", _wrap__MakeOIS_withRule, METH_VARARGS, "_MakeOIS_withRule(_MakeOIS self, DateGeneration::Rule r) -> _MakeOIS"},
	 { "_MakeOIS_withPaymentFrequency", _wrap__MakeOIS_withPaymentFrequency, METH_VARARGS, "_MakeOIS_withPaymentFrequency(_MakeOIS self, Frequency f) -> _MakeOIS"},
	 { "_MakeOIS_withPaymentAdjustment", _wrap__MakeOIS_withPaymentAdjustment, METH_VARARGS, "_MakeOIS_withPaymentAdjustment(_MakeOIS self, BusinessDayConvention convention) -> _MakeOIS"},
	 { "_MakeOIS_withPaymentLag", _wrap__MakeOIS_withPaymentLag, METH_VARARGS, "_MakeOIS_withPaymentLag(_MakeOIS self, Integer lag) -> _MakeOIS"},
	 { "_MakeOIS_withPaymentCalendar", _wrap__MakeOIS_withPaymentCalendar, METH_VARARGS, "_MakeOIS_withPaymentCalendar(_MakeOIS self, Calendar cal) -> _MakeOIS"},
	 { "_MakeOIS_withEndOfMonth", _wrap__MakeOIS_withEndOfMonth, METH_VARARGS, "_MakeOIS_withEndOfMonth(_MakeOIS self, bool flag=True) -> _MakeOIS"},
	 { "_MakeOIS_withFixedLegDayCount", _wrap__MakeOIS_withFixedLegDayCount, METH_VARARGS, "_MakeOIS_withFixedLegDayCount(_MakeOIS self, DayCounter dc) -> _MakeOIS"},
	 { "_MakeOIS_withOvernightLegSpread", _wrap__MakeOIS_withOvernightLegSpread, METH_VARARGS, "_MakeOIS_withOvernightLegSpread(_MakeOIS self, Spread sp) -> _MakeOIS"},
	 { "_MakeOIS_withDiscountingTermStructure", _wrap__MakeOIS_withDiscountingTermStructure, METH_VARARGS, "_MakeOIS_withDiscountingTermStructure(_MakeOIS self, YieldTermStructureHandle discountingTermStructure) -> _MakeOIS"},
	 { "_MakeOIS_withTelescopicValueDates", _wrap__MakeOIS_withTelescopicValueDates, METH_VARARGS, "_MakeOIS_withTelescopicValueDates(_MakeOIS self, bool telescopicValueDates) -> _MakeOIS"},
	 { "_MakeOIS_withAveragingMethod", _wrap__MakeOIS_withAveragingMethod, METH_VARARGS, "_MakeOIS_withAveragingMethod(_MakeOIS self, RateAveraging::Type averagingMethod) -> _MakeOIS"},
	 { "_MakeOIS_withPricingEngine", _wrap__MakeOIS_withPricingEngine, METH_VARARGS, "_MakeOIS_withPricingEngine(_MakeOIS self, ext::shared_ptr< PricingEngine > const & engine) -> _MakeOIS"},
	 { "delete__MakeOIS", _wrap_delete__MakeOIS, METH_O, "delete__MakeOIS(_MakeOIS self)"},
	 { "_MakeOIS_swigregister", _MakeOIS_swigregister, METH_O, NULL},
	 { "_MakeOIS_swiginit", _MakeOIS_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexedSwapIndex", _wrap_new_OvernightIndexedSwapIndex, METH_VARARGS, "OvernightIndexedSwapIndex(std::string const & familyName, Period tenor, Natural settlementDays, Currency currency, ext::shared_ptr< OvernightIndex > const & overnightIndex, bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound)"},
	 { "OvernightIndexedSwapIndex_overnightIndex", _wrap_OvernightIndexedSwapIndex_overnightIndex, METH_O, "OvernightIndexedSwapIndex_overnightIndex(OvernightIndexedSwapIndex self) -> ext::shared_ptr< OvernightIndex >"},
	 { "OvernightIndexedSwapIndex_underlyingSwap", _wrap_OvernightIndexedSwapIndex_underlyingSwap, METH_VARARGS, "OvernightIndexedSwapIndex_underlyingSwap(OvernightIndexedSwapIndex self, Date fixingDate) -> ext::shared_ptr< OvernightIndexedSwap >"},
	 { "delete_OvernightIndexedSwapIndex", _wrap_delete_OvernightIndexedSwapIndex, METH_O, "delete_OvernightIndexedSwapIndex(OvernightIndexedSwapIndex self)"},
	 { "OvernightIndexedSwapIndex_swigregister", OvernightIndexedSwapIndex_swigregister, METH_O, NULL},
	 { "OvernightIndexedSwapIndex_swiginit", OvernightIndexedSwapIndex_swiginit, METH_VARARGS, NULL},
	 { "as_overnight_swap_index", _wrap_as_overnight_swap_index, METH_O, "as_overnight_swap_index(ext::shared_ptr< InterestRateIndex > const & index) -> ext::shared_ptr< OvernightIndexedSwap >"},
	 { "new_ZeroCouponSwap", _wrap_new_ZeroCouponSwap, METH_VARARGS, "\n"
		"ZeroCouponSwap(Swap::Type type, Real baseNominal, Date startDate, Date maturityDate, Real fixedPayment, ext::shared_ptr< IborIndex > iborIndex, Calendar paymentCalendar, BusinessDayConvention paymentConvention=Following, Natural paymentDelay=0)\n"
		"ZeroCouponSwap(Swap::Type type, Real baseNominal, Date startDate, Date maturityDate, Rate fixedRate, DayCounter fixedDayCounter, ext::shared_ptr< IborIndex > iborIndex, Calendar paymentCalendar, BusinessDayConvention paymentConvention=Following, Natural paymentDelay=0)\n"
		""},
	 { "ZeroCouponSwap_type", _wrap_ZeroCouponSwap_type, METH_O, "ZeroCouponSwap_type(ZeroCouponSwap self) -> Swap::Type"},
	 { "ZeroCouponSwap_baseNominal", _wrap_ZeroCouponSwap_baseNominal, METH_O, "ZeroCouponSwap_baseNominal(ZeroCouponSwap self) -> Real"},
	 { "ZeroCouponSwap_iborIndex", _wrap_ZeroCouponSwap_iborIndex, METH_O, "ZeroCouponSwap_iborIndex(ZeroCouponSwap self) -> ext::shared_ptr< IborIndex > const &"},
	 { "ZeroCouponSwap_fixedLeg", _wrap_ZeroCouponSwap_fixedLeg, METH_O, "ZeroCouponSwap_fixedLeg(ZeroCouponSwap self) -> Leg"},
	 { "ZeroCouponSwap_floatingLeg", _wrap_ZeroCouponSwap_floatingLeg, METH_O, "ZeroCouponSwap_floatingLeg(ZeroCouponSwap self) -> Leg"},
	 { "ZeroCouponSwap_fixedPayment", _wrap_ZeroCouponSwap_fixedPayment, METH_O, "ZeroCouponSwap_fixedPayment(ZeroCouponSwap self) -> Real"},
	 { "ZeroCouponSwap_fixedLegNPV", _wrap_ZeroCouponSwap_fixedLegNPV, METH_O, "ZeroCouponSwap_fixedLegNPV(ZeroCouponSwap self) -> Real"},
	 { "ZeroCouponSwap_floatingLegNPV", _wrap_ZeroCouponSwap_floatingLegNPV, METH_O, "ZeroCouponSwap_floatingLegNPV(ZeroCouponSwap self) -> Real"},
	 { "ZeroCouponSwap_fairFixedPayment", _wrap_ZeroCouponSwap_fairFixedPayment, METH_O, "ZeroCouponSwap_fairFixedPayment(ZeroCouponSwap self) -> Real"},
	 { "ZeroCouponSwap_fairFixedRate", _wrap_ZeroCouponSwap_fairFixedRate, METH_VARARGS, "ZeroCouponSwap_fairFixedRate(ZeroCouponSwap self, DayCounter dayCounter) -> Rate"},
	 { "delete_ZeroCouponSwap", _wrap_delete_ZeroCouponSwap, METH_O, "delete_ZeroCouponSwap(ZeroCouponSwap self)"},
	 { "ZeroCouponSwap_swigregister", ZeroCouponSwap_swigregister, METH_O, NULL},
	 { "ZeroCouponSwap_swiginit", ZeroCouponSwap_swiginit, METH_VARARGS, NULL},
	 { "new_EquityTotalReturnSwap", _wrap_new_EquityTotalReturnSwap, METH_VARARGS, "\n"
		"EquityTotalReturnSwap(Swap::Type type, Real nominal, Schedule schedule, ext::shared_ptr< EquityIndex > equityIndex, ext::shared_ptr< IborIndex > const & interestRateIndex, DayCounter dayCounter, Rate margin, Real gearing=1.0, Calendar paymentCalendar=Calendar(), BusinessDayConvention paymentConvention=Unadjusted, Natural paymentDelay=0)\n"
		"EquityTotalReturnSwap(Swap::Type type, Real nominal, Schedule schedule, ext::shared_ptr< EquityIndex > equityIndex, ext::shared_ptr< OvernightIndex > const & interestRateIndex, DayCounter dayCounter, Rate margin, Real gearing=1.0, Calendar paymentCalendar=Calendar(), BusinessDayConvention paymentConvention=Unadjusted, Natural paymentDelay=0)\n"
		""},
	 { "EquityTotalReturnSwap_type", _wrap_EquityTotalReturnSwap_type, METH_O, "EquityTotalReturnSwap_type(EquityTotalReturnSwap self) -> Swap::Type"},
	 { "EquityTotalReturnSwap_nominal", _wrap_EquityTotalReturnSwap_nominal, METH_O, "EquityTotalReturnSwap_nominal(EquityTotalReturnSwap self) -> Real"},
	 { "EquityTotalReturnSwap_equityIndex", _wrap_EquityTotalReturnSwap_equityIndex, METH_O, "EquityTotalReturnSwap_equityIndex(EquityTotalReturnSwap self) -> ext::shared_ptr< EquityIndex > const &"},
	 { "EquityTotalReturnSwap_interestRateIndex", _wrap_EquityTotalReturnSwap_interestRateIndex, METH_O, "EquityTotalReturnSwap_interestRateIndex(EquityTotalReturnSwap self) -> ext::shared_ptr< InterestRateIndex > const &"},
	 { "EquityTotalReturnSwap_schedule", _wrap_EquityTotalReturnSwap_schedule, METH_O, "EquityTotalReturnSwap_schedule(EquityTotalReturnSwap self) -> Schedule"},
	 { "EquityTotalReturnSwap_dayCounter", _wrap_EquityTotalReturnSwap_dayCounter, METH_O, "EquityTotalReturnSwap_dayCounter(EquityTotalReturnSwap self) -> DayCounter"},
	 { "EquityTotalReturnSwap_margin", _wrap_EquityTotalReturnSwap_margin, METH_O, "EquityTotalReturnSwap_margin(EquityTotalReturnSwap self) -> Rate"},
	 { "EquityTotalReturnSwap_gearing", _wrap_EquityTotalReturnSwap_gearing, METH_O, "EquityTotalReturnSwap_gearing(EquityTotalReturnSwap self) -> Real"},
	 { "EquityTotalReturnSwap_paymentCalendar", _wrap_EquityTotalReturnSwap_paymentCalendar, METH_O, "EquityTotalReturnSwap_paymentCalendar(EquityTotalReturnSwap self) -> Calendar"},
	 { "EquityTotalReturnSwap_paymentConvention", _wrap_EquityTotalReturnSwap_paymentConvention, METH_O, "EquityTotalReturnSwap_paymentConvention(EquityTotalReturnSwap self) -> BusinessDayConvention"},
	 { "EquityTotalReturnSwap_paymentDelay", _wrap_EquityTotalReturnSwap_paymentDelay, METH_O, "EquityTotalReturnSwap_paymentDelay(EquityTotalReturnSwap self) -> Natural"},
	 { "EquityTotalReturnSwap_equityLeg", _wrap_EquityTotalReturnSwap_equityLeg, METH_O, "EquityTotalReturnSwap_equityLeg(EquityTotalReturnSwap self) -> Leg"},
	 { "EquityTotalReturnSwap_interestRateLeg", _wrap_EquityTotalReturnSwap_interestRateLeg, METH_O, "EquityTotalReturnSwap_interestRateLeg(EquityTotalReturnSwap self) -> Leg"},
	 { "EquityTotalReturnSwap_equityLegNPV", _wrap_EquityTotalReturnSwap_equityLegNPV, METH_O, "EquityTotalReturnSwap_equityLegNPV(EquityTotalReturnSwap self) -> Real"},
	 { "EquityTotalReturnSwap_interestRateLegNPV", _wrap_EquityTotalReturnSwap_interestRateLegNPV, METH_O, "EquityTotalReturnSwap_interestRateLegNPV(EquityTotalReturnSwap self) -> Real"},
	 { "EquityTotalReturnSwap_fairMargin", _wrap_EquityTotalReturnSwap_fairMargin, METH_O, "EquityTotalReturnSwap_fairMargin(EquityTotalReturnSwap self) -> Real"},
	 { "delete_EquityTotalReturnSwap", _wrap_delete_EquityTotalReturnSwap, METH_O, "delete_EquityTotalReturnSwap(EquityTotalReturnSwap self)"},
	 { "EquityTotalReturnSwap_swigregister", EquityTotalReturnSwap_swigregister, METH_O, NULL},
	 { "EquityTotalReturnSwap_swiginit", EquityTotalReturnSwap_swiginit, METH_VARARGS, NULL},
	 { "new_ArithmeticAverageOIS", _wrap_new_ArithmeticAverageOIS, METH_VARARGS, "\n"
		"ArithmeticAverageOIS(Swap::Type type, Real nominal, Schedule fixedLegSchedule, Rate fixedRate, DayCounter fixedDC, ext::shared_ptr< OvernightIndex > overnightIndex, Schedule overnightLegSchedule, Spread spread=0.0, Real meanReversionSpeed=0.03, Real volatility=0.00, bool byApprox=False)\n"
		"ArithmeticAverageOIS(Swap::Type type, DoubleVector nominals, Schedule fixedLegSchedule, Rate fixedRate, DayCounter fixedDC, ext::shared_ptr< OvernightIndex > overnightIndex, Schedule overnightLegSchedule, Spread spread=0.0, Real meanReversionSpeed=0.03, Real volatility=0.00, bool byApprox=False)\n"
		""},
	 { "ArithmeticAverageOIS_type", _wrap_ArithmeticAverageOIS_type, METH_O, "ArithmeticAverageOIS_type(ArithmeticAverageOIS self) -> Swap::Type"},
	 { "ArithmeticAverageOIS_nominal", _wrap_ArithmeticAverageOIS_nominal, METH_O, "ArithmeticAverageOIS_nominal(ArithmeticAverageOIS self) -> Real"},
	 { "ArithmeticAverageOIS_nominals", _wrap_ArithmeticAverageOIS_nominals, METH_O, "ArithmeticAverageOIS_nominals(ArithmeticAverageOIS self) -> DoubleVector"},
	 { "ArithmeticAverageOIS_fixedLegPaymentFrequency", _wrap_ArithmeticAverageOIS_fixedLegPaymentFrequency, METH_O, "ArithmeticAverageOIS_fixedLegPaymentFrequency(ArithmeticAverageOIS self) -> Frequency"},
	 { "ArithmeticAverageOIS_overnightLegPaymentFrequency", _wrap_ArithmeticAverageOIS_overnightLegPaymentFrequency, METH_O, "ArithmeticAverageOIS_overnightLegPaymentFrequency(ArithmeticAverageOIS self) -> Frequency"},
	 { "ArithmeticAverageOIS_fixedRate", _wrap_ArithmeticAverageOIS_fixedRate, METH_O, "ArithmeticAverageOIS_fixedRate(ArithmeticAverageOIS self) -> Rate"},
	 { "ArithmeticAverageOIS_fixedDayCount", _wrap_ArithmeticAverageOIS_fixedDayCount, METH_O, "ArithmeticAverageOIS_fixedDayCount(ArithmeticAverageOIS self) -> DayCounter"},
	 { "ArithmeticAverageOIS_overnightIndex", _wrap_ArithmeticAverageOIS_overnightIndex, METH_O, "ArithmeticAverageOIS_overnightIndex(ArithmeticAverageOIS self) -> ext::shared_ptr< OvernightIndex >"},
	 { "ArithmeticAverageOIS_spread", _wrap_ArithmeticAverageOIS_spread, METH_O, "ArithmeticAverageOIS_spread(ArithmeticAverageOIS self) -> Spread"},
	 { "ArithmeticAverageOIS_fixedLeg", _wrap_ArithmeticAverageOIS_fixedLeg, METH_O, "ArithmeticAverageOIS_fixedLeg(ArithmeticAverageOIS self) -> Leg"},
	 { "ArithmeticAverageOIS_overnightLeg", _wrap_ArithmeticAverageOIS_overnightLeg, METH_O, "ArithmeticAverageOIS_overnightLeg(ArithmeticAverageOIS self) -> Leg"},
	 { "ArithmeticAverageOIS_fixedLegBPS", _wrap_ArithmeticAverageOIS_fixedLegBPS, METH_O, "ArithmeticAverageOIS_fixedLegBPS(ArithmeticAverageOIS self) -> Real"},
	 { "ArithmeticAverageOIS_fixedLegNPV", _wrap_ArithmeticAverageOIS_fixedLegNPV, METH_O, "ArithmeticAverageOIS_fixedLegNPV(ArithmeticAverageOIS self) -> Real"},
	 { "ArithmeticAverageOIS_fairRate", _wrap_ArithmeticAverageOIS_fairRate, METH_O, "ArithmeticAverageOIS_fairRate(ArithmeticAverageOIS self) -> Real"},
	 { "ArithmeticAverageOIS_overnightLegBPS", _wrap_ArithmeticAverageOIS_overnightLegBPS, METH_O, "ArithmeticAverageOIS_overnightLegBPS(ArithmeticAverageOIS self) -> Real"},
	 { "ArithmeticAverageOIS_overnightLegNPV", _wrap_ArithmeticAverageOIS_overnightLegNPV, METH_O, "ArithmeticAverageOIS_overnightLegNPV(ArithmeticAverageOIS self) -> Real"},
	 { "ArithmeticAverageOIS_fairSpread", _wrap_ArithmeticAverageOIS_fairSpread, METH_O, "ArithmeticAverageOIS_fairSpread(ArithmeticAverageOIS self) -> Spread"},
	 { "delete_ArithmeticAverageOIS", _wrap_delete_ArithmeticAverageOIS, METH_O, "delete_ArithmeticAverageOIS(ArithmeticAverageOIS self)"},
	 { "ArithmeticAverageOIS_swigregister", ArithmeticAverageOIS_swigregister, METH_O, NULL},
	 { "ArithmeticAverageOIS_swiginit", ArithmeticAverageOIS_swiginit, METH_VARARGS, NULL},
	 { "Seasonality_correctZeroRate", _wrap_Seasonality_correctZeroRate, METH_VARARGS, "Seasonality_correctZeroRate(Seasonality self, Date d, Rate const r, InflationTermStructure iTS) -> Rate"},
	 { "Seasonality_correctYoYRate", _wrap_Seasonality_correctYoYRate, METH_VARARGS, "Seasonality_correctYoYRate(Seasonality self, Date d, Rate const r, InflationTermStructure iTS) -> Rate"},
	 { "Seasonality_isConsistent", _wrap_Seasonality_isConsistent, METH_VARARGS, "Seasonality_isConsistent(Seasonality self, InflationTermStructure iTS) -> bool"},
	 { "delete_Seasonality", _wrap_delete_Seasonality, METH_O, "delete_Seasonality(Seasonality self)"},
	 { "Seasonality_swigregister", Seasonality_swigregister, METH_O, NULL},
	 { "new_MultiplicativePriceSeasonality", _wrap_new_MultiplicativePriceSeasonality, METH_VARARGS, "new_MultiplicativePriceSeasonality(Date seasonalityBaseDate, Frequency frequency, DoubleVector seasonalityFactors) -> MultiplicativePriceSeasonality"},
	 { "delete_MultiplicativePriceSeasonality", _wrap_delete_MultiplicativePriceSeasonality, METH_O, "delete_MultiplicativePriceSeasonality(MultiplicativePriceSeasonality self)"},
	 { "MultiplicativePriceSeasonality_swigregister", MultiplicativePriceSeasonality_swigregister, METH_O, NULL},
	 { "MultiplicativePriceSeasonality_swiginit", MultiplicativePriceSeasonality_swiginit, METH_VARARGS, NULL},
	 { "new_KerkhofSeasonality", _wrap_new_KerkhofSeasonality, METH_VARARGS, "new_KerkhofSeasonality(Date seasonalityBaseDate, DoubleVector seasonalityFactors) -> KerkhofSeasonality"},
	 { "delete_KerkhofSeasonality", _wrap_delete_KerkhofSeasonality, METH_O, "delete_KerkhofSeasonality(KerkhofSeasonality self)"},
	 { "KerkhofSeasonality_swigregister", KerkhofSeasonality_swigregister, METH_O, NULL},
	 { "KerkhofSeasonality_swiginit", KerkhofSeasonality_swiginit, METH_VARARGS, NULL},
	 { "InflationTermStructure_observationLag", _wrap_InflationTermStructure_observationLag, METH_O, "InflationTermStructure_observationLag(InflationTermStructure self) -> Period"},
	 { "InflationTermStructure_frequency", _wrap_InflationTermStructure_frequency, METH_O, "InflationTermStructure_frequency(InflationTermStructure self) -> Frequency"},
	 { "InflationTermStructure_baseRate", _wrap_InflationTermStructure_baseRate, METH_O, "InflationTermStructure_baseRate(InflationTermStructure self) -> Rate"},
	 { "InflationTermStructure_baseDate", _wrap_InflationTermStructure_baseDate, METH_O, "InflationTermStructure_baseDate(InflationTermStructure self) -> Date"},
	 { "InflationTermStructure_setSeasonality", _wrap_InflationTermStructure_setSeasonality, METH_VARARGS, "InflationTermStructure_setSeasonality(InflationTermStructure self, ext::shared_ptr< Seasonality > const & seasonality=ext::shared_ptr< Seasonality >())"},
	 { "InflationTermStructure_seasonality", _wrap_InflationTermStructure_seasonality, METH_O, "InflationTermStructure_seasonality(InflationTermStructure self) -> ext::shared_ptr< Seasonality >"},
	 { "InflationTermStructure_hasSeasonality", _wrap_InflationTermStructure_hasSeasonality, METH_O, "InflationTermStructure_hasSeasonality(InflationTermStructure self) -> bool"},
	 { "delete_InflationTermStructure", _wrap_delete_InflationTermStructure, METH_O, "delete_InflationTermStructure(InflationTermStructure self)"},
	 { "InflationTermStructure_swigregister", InflationTermStructure_swigregister, METH_O, NULL},
	 { "YoYInflationTermStructure_yoyRate", _wrap_YoYInflationTermStructure_yoyRate, METH_VARARGS, "\n"
		"YoYInflationTermStructure_yoyRate(YoYInflationTermStructure self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate\n"
		"YoYInflationTermStructure_yoyRate(YoYInflationTermStructure self, Time t, bool extrapolate=False) -> Rate\n"
		""},
	 { "YoYInflationTermStructure_indexIsInterpolated", _wrap_YoYInflationTermStructure_indexIsInterpolated, METH_O, "YoYInflationTermStructure_indexIsInterpolated(YoYInflationTermStructure self) -> bool"},
	 { "delete_YoYInflationTermStructure", _wrap_delete_YoYInflationTermStructure, METH_O, "delete_YoYInflationTermStructure(YoYInflationTermStructure self)"},
	 { "YoYInflationTermStructure_swigregister", YoYInflationTermStructure_swigregister, METH_O, NULL},
	 { "new_YoYInflationTermStructureHandle", _wrap_new_YoYInflationTermStructureHandle, METH_VARARGS, "YoYInflationTermStructureHandle(ext::shared_ptr< YoYInflationTermStructure > const & arg1=ext::shared_ptr())"},
	 { "YoYInflationTermStructureHandle___deref__", _wrap_YoYInflationTermStructureHandle___deref__, METH_O, "YoYInflationTermStructureHandle___deref__(YoYInflationTermStructureHandle self) -> ext::shared_ptr< YoYInflationTermStructure >"},
	 { "YoYInflationTermStructureHandle_currentLink", _wrap_YoYInflationTermStructureHandle_currentLink, METH_O, "YoYInflationTermStructureHandle_currentLink(YoYInflationTermStructureHandle self) -> ext::shared_ptr< YoYInflationTermStructure >"},
	 { "YoYInflationTermStructureHandle___nonzero__", _wrap_YoYInflationTermStructureHandle___nonzero__, METH_O, "YoYInflationTermStructureHandle___nonzero__(YoYInflationTermStructureHandle self) -> bool"},
	 { "YoYInflationTermStructureHandle___bool__", _wrap_YoYInflationTermStructureHandle___bool__, METH_O, "YoYInflationTermStructureHandle___bool__(YoYInflationTermStructureHandle self) -> bool"},
	 { "YoYInflationTermStructureHandle_asObservable", _wrap_YoYInflationTermStructureHandle_asObservable, METH_O, "YoYInflationTermStructureHandle_asObservable(YoYInflationTermStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_YoYInflationTermStructureHandle", _wrap_delete_YoYInflationTermStructureHandle, METH_O, "delete_YoYInflationTermStructureHandle(YoYInflationTermStructureHandle self)"},
	 { "YoYInflationTermStructureHandle_yoyRate", _wrap_YoYInflationTermStructureHandle_yoyRate, METH_VARARGS, "\n"
		"YoYInflationTermStructureHandle_yoyRate(YoYInflationTermStructureHandle self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate\n"
		"YoYInflationTermStructureHandle_yoyRate(YoYInflationTermStructureHandle self, Time t, bool extrapolate=False) -> Rate\n"
		""},
	 { "YoYInflationTermStructureHandle_indexIsInterpolated", _wrap_YoYInflationTermStructureHandle_indexIsInterpolated, METH_O, "YoYInflationTermStructureHandle_indexIsInterpolated(YoYInflationTermStructureHandle self) -> bool"},
	 { "YoYInflationTermStructureHandle_observationLag", _wrap_YoYInflationTermStructureHandle_observationLag, METH_O, "YoYInflationTermStructureHandle_observationLag(YoYInflationTermStructureHandle self) -> Period"},
	 { "YoYInflationTermStructureHandle_frequency", _wrap_YoYInflationTermStructureHandle_frequency, METH_O, "YoYInflationTermStructureHandle_frequency(YoYInflationTermStructureHandle self) -> Frequency"},
	 { "YoYInflationTermStructureHandle_baseRate", _wrap_YoYInflationTermStructureHandle_baseRate, METH_O, "YoYInflationTermStructureHandle_baseRate(YoYInflationTermStructureHandle self) -> Rate"},
	 { "YoYInflationTermStructureHandle_baseDate", _wrap_YoYInflationTermStructureHandle_baseDate, METH_O, "YoYInflationTermStructureHandle_baseDate(YoYInflationTermStructureHandle self) -> Date"},
	 { "YoYInflationTermStructureHandle_setSeasonality", _wrap_YoYInflationTermStructureHandle_setSeasonality, METH_VARARGS, "YoYInflationTermStructureHandle_setSeasonality(YoYInflationTermStructureHandle self, ext::shared_ptr< Seasonality > const & seasonality=ext::shared_ptr< Seasonality >())"},
	 { "YoYInflationTermStructureHandle_seasonality", _wrap_YoYInflationTermStructureHandle_seasonality, METH_O, "YoYInflationTermStructureHandle_seasonality(YoYInflationTermStructureHandle self) -> ext::shared_ptr< Seasonality >"},
	 { "YoYInflationTermStructureHandle_hasSeasonality", _wrap_YoYInflationTermStructureHandle_hasSeasonality, METH_O, "YoYInflationTermStructureHandle_hasSeasonality(YoYInflationTermStructureHandle self) -> bool"},
	 { "YoYInflationTermStructureHandle_dayCounter", _wrap_YoYInflationTermStructureHandle_dayCounter, METH_O, "YoYInflationTermStructureHandle_dayCounter(YoYInflationTermStructureHandle self) -> DayCounter"},
	 { "YoYInflationTermStructureHandle_timeFromReference", _wrap_YoYInflationTermStructureHandle_timeFromReference, METH_VARARGS, "YoYInflationTermStructureHandle_timeFromReference(YoYInflationTermStructureHandle self, Date date) -> Time"},
	 { "YoYInflationTermStructureHandle_calendar", _wrap_YoYInflationTermStructureHandle_calendar, METH_O, "YoYInflationTermStructureHandle_calendar(YoYInflationTermStructureHandle self) -> Calendar"},
	 { "YoYInflationTermStructureHandle_referenceDate", _wrap_YoYInflationTermStructureHandle_referenceDate, METH_O, "YoYInflationTermStructureHandle_referenceDate(YoYInflationTermStructureHandle self) -> Date"},
	 { "YoYInflationTermStructureHandle_maxDate", _wrap_YoYInflationTermStructureHandle_maxDate, METH_O, "YoYInflationTermStructureHandle_maxDate(YoYInflationTermStructureHandle self) -> Date"},
	 { "YoYInflationTermStructureHandle_maxTime", _wrap_YoYInflationTermStructureHandle_maxTime, METH_O, "YoYInflationTermStructureHandle_maxTime(YoYInflationTermStructureHandle self) -> Time"},
	 { "YoYInflationTermStructureHandle_enableExtrapolation", _wrap_YoYInflationTermStructureHandle_enableExtrapolation, METH_O, "YoYInflationTermStructureHandle_enableExtrapolation(YoYInflationTermStructureHandle self)"},
	 { "YoYInflationTermStructureHandle_disableExtrapolation", _wrap_YoYInflationTermStructureHandle_disableExtrapolation, METH_O, "YoYInflationTermStructureHandle_disableExtrapolation(YoYInflationTermStructureHandle self)"},
	 { "YoYInflationTermStructureHandle_allowsExtrapolation", _wrap_YoYInflationTermStructureHandle_allowsExtrapolation, METH_O, "YoYInflationTermStructureHandle_allowsExtrapolation(YoYInflationTermStructureHandle self) -> bool"},
	 { "YoYInflationTermStructureHandle_swigregister", YoYInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "YoYInflationTermStructureHandle_swiginit", YoYInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableYoYInflationTermStructureHandle", _wrap_new_RelinkableYoYInflationTermStructureHandle, METH_VARARGS, "RelinkableYoYInflationTermStructureHandle(ext::shared_ptr< YoYInflationTermStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableYoYInflationTermStructureHandle_linkTo", _wrap_RelinkableYoYInflationTermStructureHandle_linkTo, METH_VARARGS, "RelinkableYoYInflationTermStructureHandle_linkTo(RelinkableYoYInflationTermStructureHandle self, ext::shared_ptr< YoYInflationTermStructure > const & arg2)"},
	 { "RelinkableYoYInflationTermStructureHandle_reset", _wrap_RelinkableYoYInflationTermStructureHandle_reset, METH_O, "RelinkableYoYInflationTermStructureHandle_reset(RelinkableYoYInflationTermStructureHandle self)"},
	 { "delete_RelinkableYoYInflationTermStructureHandle", _wrap_delete_RelinkableYoYInflationTermStructureHandle, METH_O, "delete_RelinkableYoYInflationTermStructureHandle(RelinkableYoYInflationTermStructureHandle self)"},
	 { "RelinkableYoYInflationTermStructureHandle_swigregister", RelinkableYoYInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableYoYInflationTermStructureHandle_swiginit", RelinkableYoYInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "ZeroInflationTermStructure_zeroRate", _wrap_ZeroInflationTermStructure_zeroRate, METH_VARARGS, "\n"
		"ZeroInflationTermStructure_zeroRate(ZeroInflationTermStructure self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate\n"
		"ZeroInflationTermStructure_zeroRate(ZeroInflationTermStructure self, Time t, bool extrapolate=False) -> Rate\n"
		""},
	 { "delete_ZeroInflationTermStructure", _wrap_delete_ZeroInflationTermStructure, METH_O, "delete_ZeroInflationTermStructure(ZeroInflationTermStructure self)"},
	 { "ZeroInflationTermStructure_swigregister", ZeroInflationTermStructure_swigregister, METH_O, NULL},
	 { "new_ZeroInflationTermStructureHandle", _wrap_new_ZeroInflationTermStructureHandle, METH_VARARGS, "ZeroInflationTermStructureHandle(ext::shared_ptr< ZeroInflationTermStructure > const & arg1=ext::shared_ptr())"},
	 { "ZeroInflationTermStructureHandle___deref__", _wrap_ZeroInflationTermStructureHandle___deref__, METH_O, "ZeroInflationTermStructureHandle___deref__(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< ZeroInflationTermStructure >"},
	 { "ZeroInflationTermStructureHandle_currentLink", _wrap_ZeroInflationTermStructureHandle_currentLink, METH_O, "ZeroInflationTermStructureHandle_currentLink(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< ZeroInflationTermStructure >"},
	 { "ZeroInflationTermStructureHandle___nonzero__", _wrap_ZeroInflationTermStructureHandle___nonzero__, METH_O, "ZeroInflationTermStructureHandle___nonzero__(ZeroInflationTermStructureHandle self) -> bool"},
	 { "ZeroInflationTermStructureHandle___bool__", _wrap_ZeroInflationTermStructureHandle___bool__, METH_O, "ZeroInflationTermStructureHandle___bool__(ZeroInflationTermStructureHandle self) -> bool"},
	 { "ZeroInflationTermStructureHandle_asObservable", _wrap_ZeroInflationTermStructureHandle_asObservable, METH_O, "ZeroInflationTermStructureHandle_asObservable(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_ZeroInflationTermStructureHandle", _wrap_delete_ZeroInflationTermStructureHandle, METH_O, "delete_ZeroInflationTermStructureHandle(ZeroInflationTermStructureHandle self)"},
	 { "ZeroInflationTermStructureHandle_zeroRate", _wrap_ZeroInflationTermStructureHandle_zeroRate, METH_VARARGS, "\n"
		"ZeroInflationTermStructureHandle_zeroRate(ZeroInflationTermStructureHandle self, Date d, Period instObsLag=Period(-1,Days), bool forceLinearInterpolation=False, bool extrapolate=False) -> Rate\n"
		"ZeroInflationTermStructureHandle_zeroRate(ZeroInflationTermStructureHandle self, Time t, bool extrapolate=False) -> Rate\n"
		""},
	 { "ZeroInflationTermStructureHandle_observationLag", _wrap_ZeroInflationTermStructureHandle_observationLag, METH_O, "ZeroInflationTermStructureHandle_observationLag(ZeroInflationTermStructureHandle self) -> Period"},
	 { "ZeroInflationTermStructureHandle_frequency", _wrap_ZeroInflationTermStructureHandle_frequency, METH_O, "ZeroInflationTermStructureHandle_frequency(ZeroInflationTermStructureHandle self) -> Frequency"},
	 { "ZeroInflationTermStructureHandle_baseRate", _wrap_ZeroInflationTermStructureHandle_baseRate, METH_O, "ZeroInflationTermStructureHandle_baseRate(ZeroInflationTermStructureHandle self) -> Rate"},
	 { "ZeroInflationTermStructureHandle_baseDate", _wrap_ZeroInflationTermStructureHandle_baseDate, METH_O, "ZeroInflationTermStructureHandle_baseDate(ZeroInflationTermStructureHandle self) -> Date"},
	 { "ZeroInflationTermStructureHandle_setSeasonality", _wrap_ZeroInflationTermStructureHandle_setSeasonality, METH_VARARGS, "ZeroInflationTermStructureHandle_setSeasonality(ZeroInflationTermStructureHandle self, ext::shared_ptr< Seasonality > const & seasonality=ext::shared_ptr< Seasonality >())"},
	 { "ZeroInflationTermStructureHandle_seasonality", _wrap_ZeroInflationTermStructureHandle_seasonality, METH_O, "ZeroInflationTermStructureHandle_seasonality(ZeroInflationTermStructureHandle self) -> ext::shared_ptr< Seasonality >"},
	 { "ZeroInflationTermStructureHandle_hasSeasonality", _wrap_ZeroInflationTermStructureHandle_hasSeasonality, METH_O, "ZeroInflationTermStructureHandle_hasSeasonality(ZeroInflationTermStructureHandle self) -> bool"},
	 { "ZeroInflationTermStructureHandle_dayCounter", _wrap_ZeroInflationTermStructureHandle_dayCounter, METH_O, "ZeroInflationTermStructureHandle_dayCounter(ZeroInflationTermStructureHandle self) -> DayCounter"},
	 { "ZeroInflationTermStructureHandle_timeFromReference", _wrap_ZeroInflationTermStructureHandle_timeFromReference, METH_VARARGS, "ZeroInflationTermStructureHandle_timeFromReference(ZeroInflationTermStructureHandle self, Date date) -> Time"},
	 { "ZeroInflationTermStructureHandle_calendar", _wrap_ZeroInflationTermStructureHandle_calendar, METH_O, "ZeroInflationTermStructureHandle_calendar(ZeroInflationTermStructureHandle self) -> Calendar"},
	 { "ZeroInflationTermStructureHandle_referenceDate", _wrap_ZeroInflationTermStructureHandle_referenceDate, METH_O, "ZeroInflationTermStructureHandle_referenceDate(ZeroInflationTermStructureHandle self) -> Date"},
	 { "ZeroInflationTermStructureHandle_maxDate", _wrap_ZeroInflationTermStructureHandle_maxDate, METH_O, "ZeroInflationTermStructureHandle_maxDate(ZeroInflationTermStructureHandle self) -> Date"},
	 { "ZeroInflationTermStructureHandle_maxTime", _wrap_ZeroInflationTermStructureHandle_maxTime, METH_O, "ZeroInflationTermStructureHandle_maxTime(ZeroInflationTermStructureHandle self) -> Time"},
	 { "ZeroInflationTermStructureHandle_enableExtrapolation", _wrap_ZeroInflationTermStructureHandle_enableExtrapolation, METH_O, "ZeroInflationTermStructureHandle_enableExtrapolation(ZeroInflationTermStructureHandle self)"},
	 { "ZeroInflationTermStructureHandle_disableExtrapolation", _wrap_ZeroInflationTermStructureHandle_disableExtrapolation, METH_O, "ZeroInflationTermStructureHandle_disableExtrapolation(ZeroInflationTermStructureHandle self)"},
	 { "ZeroInflationTermStructureHandle_allowsExtrapolation", _wrap_ZeroInflationTermStructureHandle_allowsExtrapolation, METH_O, "ZeroInflationTermStructureHandle_allowsExtrapolation(ZeroInflationTermStructureHandle self) -> bool"},
	 { "ZeroInflationTermStructureHandle_swigregister", ZeroInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "ZeroInflationTermStructureHandle_swiginit", ZeroInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableZeroInflationTermStructureHandle", _wrap_new_RelinkableZeroInflationTermStructureHandle, METH_VARARGS, "RelinkableZeroInflationTermStructureHandle(ext::shared_ptr< ZeroInflationTermStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableZeroInflationTermStructureHandle_linkTo", _wrap_RelinkableZeroInflationTermStructureHandle_linkTo, METH_VARARGS, "RelinkableZeroInflationTermStructureHandle_linkTo(RelinkableZeroInflationTermStructureHandle self, ext::shared_ptr< ZeroInflationTermStructure > const & arg2)"},
	 { "RelinkableZeroInflationTermStructureHandle_reset", _wrap_RelinkableZeroInflationTermStructureHandle_reset, METH_O, "RelinkableZeroInflationTermStructureHandle_reset(RelinkableZeroInflationTermStructureHandle self)"},
	 { "delete_RelinkableZeroInflationTermStructureHandle", _wrap_delete_RelinkableZeroInflationTermStructureHandle, METH_O, "delete_RelinkableZeroInflationTermStructureHandle(RelinkableZeroInflationTermStructureHandle self)"},
	 { "RelinkableZeroInflationTermStructureHandle_swigregister", RelinkableZeroInflationTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableZeroInflationTermStructureHandle_swiginit", RelinkableZeroInflationTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "Region_name", _wrap_Region_name, METH_O, "Region_name(Region self) -> std::string"},
	 { "Region_code", _wrap_Region_code, METH_O, "Region_code(Region self) -> std::string"},
	 { "delete_Region", _wrap_delete_Region, METH_O, "delete_Region(Region self)"},
	 { "Region_swigregister", Region_swigregister, METH_O, NULL},
	 { "new_CustomRegion", _wrap_new_CustomRegion, METH_VARARGS, "new_CustomRegion(std::string const & name, std::string const & code) -> CustomRegion"},
	 { "delete_CustomRegion", _wrap_delete_CustomRegion, METH_O, "delete_CustomRegion(CustomRegion self)"},
	 { "CustomRegion_swigregister", CustomRegion_swigregister, METH_O, NULL},
	 { "CustomRegion_swiginit", CustomRegion_swiginit, METH_VARARGS, NULL},
	 { "InflationIndex_familyName", _wrap_InflationIndex_familyName, METH_O, "InflationIndex_familyName(InflationIndex self) -> std::string"},
	 { "InflationIndex_region", _wrap_InflationIndex_region, METH_O, "InflationIndex_region(InflationIndex self) -> Region"},
	 { "InflationIndex_revised", _wrap_InflationIndex_revised, METH_O, "InflationIndex_revised(InflationIndex self) -> bool"},
	 { "InflationIndex_interpolated", _wrap_InflationIndex_interpolated, METH_O, "InflationIndex_interpolated(InflationIndex self) -> bool"},
	 { "InflationIndex_frequency", _wrap_InflationIndex_frequency, METH_O, "InflationIndex_frequency(InflationIndex self) -> Frequency"},
	 { "InflationIndex_availabilityLag", _wrap_InflationIndex_availabilityLag, METH_O, "InflationIndex_availabilityLag(InflationIndex self) -> Period"},
	 { "InflationIndex_currency", _wrap_InflationIndex_currency, METH_O, "InflationIndex_currency(InflationIndex self) -> Currency"},
	 { "delete_InflationIndex", _wrap_delete_InflationIndex, METH_O, "delete_InflationIndex(InflationIndex self)"},
	 { "InflationIndex_swigregister", InflationIndex_swigregister, METH_O, NULL},
	 { "new_ZeroInflationIndex", _wrap_new_ZeroInflationIndex, METH_VARARGS, "\n"
		"ZeroInflationIndex(std::string const & familyName, Region region, bool revised, Frequency frequency, Period availabilityLag, Currency currency, ZeroInflationTermStructureHandle h={})\n"
		"ZeroInflationIndex(std::string const & familyName, Region region, bool revised, bool interpolated, Frequency frequency, Period availabilityLag, Currency currency, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "ZeroInflationIndex_zeroInflationTermStructure", _wrap_ZeroInflationIndex_zeroInflationTermStructure, METH_O, "ZeroInflationIndex_zeroInflationTermStructure(ZeroInflationIndex self) -> ZeroInflationTermStructureHandle"},
	 { "ZeroInflationIndex_clone", _wrap_ZeroInflationIndex_clone, METH_VARARGS, "ZeroInflationIndex_clone(ZeroInflationIndex self, ZeroInflationTermStructureHandle h) -> ext::shared_ptr< ZeroInflationIndex >"},
	 { "delete_ZeroInflationIndex", _wrap_delete_ZeroInflationIndex, METH_O, "delete_ZeroInflationIndex(ZeroInflationIndex self)"},
	 { "ZeroInflationIndex_swigregister", ZeroInflationIndex_swigregister, METH_O, NULL},
	 { "ZeroInflationIndex_swiginit", ZeroInflationIndex_swiginit, METH_VARARGS, NULL},
	 { "as_zero_inflation_index", _wrap_as_zero_inflation_index, METH_O, "as_zero_inflation_index(ext::shared_ptr< Index > const & i) -> ext::shared_ptr< ZeroInflationIndex >"},
	 { "new_YoYInflationIndex", _wrap_new_YoYInflationIndex, METH_VARARGS, "\n"
		"YoYInflationIndex(ext::shared_ptr< ZeroInflationIndex > const & underlyingIndex, bool interpolated, YoYInflationTermStructureHandle ts={})\n"
		"YoYInflationIndex(std::string const & familyName, Region region, bool revised, bool interpolated, Frequency frequency, Period availabilityLag, Currency currency, YoYInflationTermStructureHandle ts={})\n"
		"YoYInflationIndex(std::string const & familyName, Region region, bool revised, bool interpolated, bool ratio, Frequency frequency, Period availabilityLag, Currency currency, YoYInflationTermStructureHandle ts={})\n"
		""},
	 { "YoYInflationIndex_ratio", _wrap_YoYInflationIndex_ratio, METH_O, "YoYInflationIndex_ratio(YoYInflationIndex self) -> bool"},
	 { "YoYInflationIndex_underlyingIndex", _wrap_YoYInflationIndex_underlyingIndex, METH_O, "YoYInflationIndex_underlyingIndex(YoYInflationIndex self) -> ext::shared_ptr< ZeroInflationIndex >"},
	 { "YoYInflationIndex_yoyInflationTermStructure", _wrap_YoYInflationIndex_yoyInflationTermStructure, METH_O, "YoYInflationIndex_yoyInflationTermStructure(YoYInflationIndex self) -> YoYInflationTermStructureHandle"},
	 { "YoYInflationIndex_clone", _wrap_YoYInflationIndex_clone, METH_VARARGS, "YoYInflationIndex_clone(YoYInflationIndex self, YoYInflationTermStructureHandle h) -> ext::shared_ptr< YoYInflationIndex >"},
	 { "delete_YoYInflationIndex", _wrap_delete_YoYInflationIndex, METH_O, "delete_YoYInflationIndex(YoYInflationIndex self)"},
	 { "YoYInflationIndex_swigregister", YoYInflationIndex_swigregister, METH_O, NULL},
	 { "YoYInflationIndex_swiginit", YoYInflationIndex_swiginit, METH_VARARGS, NULL},
	 { "new_EUHICP", _wrap_new_EUHICP, METH_VARARGS, "\n"
		"EUHICP(ZeroInflationTermStructureHandle h={})\n"
		"EUHICP(bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_EUHICP", _wrap_delete_EUHICP, METH_O, "delete_EUHICP(EUHICP self)"},
	 { "EUHICP_swigregister", EUHICP_swigregister, METH_O, NULL},
	 { "EUHICP_swiginit", EUHICP_swiginit, METH_VARARGS, NULL},
	 { "new_EUHICPXT", _wrap_new_EUHICPXT, METH_VARARGS, "\n"
		"EUHICPXT(ZeroInflationTermStructureHandle h={})\n"
		"EUHICPXT(bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_EUHICPXT", _wrap_delete_EUHICPXT, METH_O, "delete_EUHICPXT(EUHICPXT self)"},
	 { "EUHICPXT_swigregister", EUHICPXT_swigregister, METH_O, NULL},
	 { "EUHICPXT_swiginit", EUHICPXT_swiginit, METH_VARARGS, NULL},
	 { "new_FRHICP", _wrap_new_FRHICP, METH_VARARGS, "\n"
		"FRHICP(ZeroInflationTermStructureHandle h={})\n"
		"FRHICP(bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_FRHICP", _wrap_delete_FRHICP, METH_O, "delete_FRHICP(FRHICP self)"},
	 { "FRHICP_swigregister", FRHICP_swigregister, METH_O, NULL},
	 { "FRHICP_swiginit", FRHICP_swiginit, METH_VARARGS, NULL},
	 { "new_UKRPI", _wrap_new_UKRPI, METH_VARARGS, "\n"
		"UKRPI(ZeroInflationTermStructureHandle h={})\n"
		"UKRPI(bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_UKRPI", _wrap_delete_UKRPI, METH_O, "delete_UKRPI(UKRPI self)"},
	 { "UKRPI_swigregister", UKRPI_swigregister, METH_O, NULL},
	 { "UKRPI_swiginit", UKRPI_swiginit, METH_VARARGS, NULL},
	 { "new_USCPI", _wrap_new_USCPI, METH_VARARGS, "\n"
		"USCPI(ZeroInflationTermStructureHandle h={})\n"
		"USCPI(bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_USCPI", _wrap_delete_USCPI, METH_O, "delete_USCPI(USCPI self)"},
	 { "USCPI_swigregister", USCPI_swigregister, METH_O, NULL},
	 { "USCPI_swiginit", USCPI_swiginit, METH_VARARGS, NULL},
	 { "new_ZACPI", _wrap_new_ZACPI, METH_VARARGS, "\n"
		"ZACPI(ZeroInflationTermStructureHandle h={})\n"
		"ZACPI(bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_ZACPI", _wrap_delete_ZACPI, METH_O, "delete_ZACPI(ZACPI self)"},
	 { "ZACPI_swigregister", ZACPI_swigregister, METH_O, NULL},
	 { "ZACPI_swiginit", ZACPI_swiginit, METH_VARARGS, NULL},
	 { "new_UKHICP", _wrap_new_UKHICP, METH_VARARGS, "UKHICP(ZeroInflationTermStructureHandle h={})"},
	 { "delete_UKHICP", _wrap_delete_UKHICP, METH_O, "delete_UKHICP(UKHICP self)"},
	 { "UKHICP_swigregister", UKHICP_swigregister, METH_O, NULL},
	 { "UKHICP_swiginit", UKHICP_swiginit, METH_VARARGS, NULL},
	 { "new_YYEUHICP", _wrap_new_YYEUHICP, METH_VARARGS, "YYEUHICP(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYEUHICP", _wrap_delete_YYEUHICP, METH_O, "delete_YYEUHICP(YYEUHICP self)"},
	 { "YYEUHICP_swigregister", YYEUHICP_swigregister, METH_O, NULL},
	 { "YYEUHICP_swiginit", YYEUHICP_swiginit, METH_VARARGS, NULL},
	 { "new_YYEUHICPXT", _wrap_new_YYEUHICPXT, METH_VARARGS, "YYEUHICPXT(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYEUHICPXT", _wrap_delete_YYEUHICPXT, METH_O, "delete_YYEUHICPXT(YYEUHICPXT self)"},
	 { "YYEUHICPXT_swigregister", YYEUHICPXT_swigregister, METH_O, NULL},
	 { "YYEUHICPXT_swiginit", YYEUHICPXT_swiginit, METH_VARARGS, NULL},
	 { "new_YYEUHICPr", _wrap_new_YYEUHICPr, METH_VARARGS, "YYEUHICPr(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYEUHICPr", _wrap_delete_YYEUHICPr, METH_O, "delete_YYEUHICPr(YYEUHICPr self)"},
	 { "YYEUHICPr_swigregister", YYEUHICPr_swigregister, METH_O, NULL},
	 { "YYEUHICPr_swiginit", YYEUHICPr_swiginit, METH_VARARGS, NULL},
	 { "new_YYFRHICP", _wrap_new_YYFRHICP, METH_VARARGS, "YYFRHICP(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYFRHICP", _wrap_delete_YYFRHICP, METH_O, "delete_YYFRHICP(YYFRHICP self)"},
	 { "YYFRHICP_swigregister", YYFRHICP_swigregister, METH_O, NULL},
	 { "YYFRHICP_swiginit", YYFRHICP_swiginit, METH_VARARGS, NULL},
	 { "new_YYFRHICPr", _wrap_new_YYFRHICPr, METH_VARARGS, "YYFRHICPr(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYFRHICPr", _wrap_delete_YYFRHICPr, METH_O, "delete_YYFRHICPr(YYFRHICPr self)"},
	 { "YYFRHICPr_swigregister", YYFRHICPr_swigregister, METH_O, NULL},
	 { "YYFRHICPr_swiginit", YYFRHICPr_swiginit, METH_VARARGS, NULL},
	 { "new_YYUKRPI", _wrap_new_YYUKRPI, METH_VARARGS, "YYUKRPI(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYUKRPI", _wrap_delete_YYUKRPI, METH_O, "delete_YYUKRPI(YYUKRPI self)"},
	 { "YYUKRPI_swigregister", YYUKRPI_swigregister, METH_O, NULL},
	 { "YYUKRPI_swiginit", YYUKRPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYUKRPIr", _wrap_new_YYUKRPIr, METH_VARARGS, "YYUKRPIr(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYUKRPIr", _wrap_delete_YYUKRPIr, METH_O, "delete_YYUKRPIr(YYUKRPIr self)"},
	 { "YYUKRPIr_swigregister", YYUKRPIr_swigregister, METH_O, NULL},
	 { "YYUKRPIr_swiginit", YYUKRPIr_swiginit, METH_VARARGS, NULL},
	 { "new_YYUSCPI", _wrap_new_YYUSCPI, METH_VARARGS, "YYUSCPI(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYUSCPI", _wrap_delete_YYUSCPI, METH_O, "delete_YYUSCPI(YYUSCPI self)"},
	 { "YYUSCPI_swigregister", YYUSCPI_swigregister, METH_O, NULL},
	 { "YYUSCPI_swiginit", YYUSCPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYUSCPIr", _wrap_new_YYUSCPIr, METH_VARARGS, "YYUSCPIr(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYUSCPIr", _wrap_delete_YYUSCPIr, METH_O, "delete_YYUSCPIr(YYUSCPIr self)"},
	 { "YYUSCPIr_swigregister", YYUSCPIr_swigregister, METH_O, NULL},
	 { "YYUSCPIr_swiginit", YYUSCPIr_swiginit, METH_VARARGS, NULL},
	 { "new_YYZACPI", _wrap_new_YYZACPI, METH_VARARGS, "YYZACPI(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYZACPI", _wrap_delete_YYZACPI, METH_O, "delete_YYZACPI(YYZACPI self)"},
	 { "YYZACPI_swigregister", YYZACPI_swigregister, METH_O, NULL},
	 { "YYZACPI_swiginit", YYZACPI_swiginit, METH_VARARGS, NULL},
	 { "new_YYZACPIr", _wrap_new_YYZACPIr, METH_VARARGS, "YYZACPIr(bool interpolated, YoYInflationTermStructureHandle h={})"},
	 { "delete_YYZACPIr", _wrap_delete_YYZACPIr, METH_O, "delete_YYZACPIr(YYZACPIr self)"},
	 { "YYZACPIr_swigregister", YYZACPIr_swigregister, METH_O, NULL},
	 { "YYZACPIr_swiginit", YYZACPIr_swiginit, METH_VARARGS, NULL},
	 { "new_AUCPI", _wrap_new_AUCPI, METH_VARARGS, "\n"
		"AUCPI(Frequency frequency, bool revised, ZeroInflationTermStructureHandle h={})\n"
		"AUCPI(Frequency frequency, bool revised, bool interpolated, ZeroInflationTermStructureHandle h={})\n"
		""},
	 { "delete_AUCPI", _wrap_delete_AUCPI, METH_O, "delete_AUCPI(AUCPI self)"},
	 { "AUCPI_swigregister", AUCPI_swigregister, METH_O, NULL},
	 { "AUCPI_swiginit", AUCPI_swiginit, METH_VARARGS, NULL},
	 { "CPI_laggedFixing", _wrap_CPI_laggedFixing, METH_VARARGS, "CPI_laggedFixing(ext::shared_ptr< ZeroInflationIndex > const & index, Date date, Period observationLag, CPI::InterpolationType interpolationType) -> Real"},
	 { "new_CPI", _wrap_new_CPI, METH_NOARGS, "new_CPI() -> CPI"},
	 { "delete_CPI", _wrap_delete_CPI, METH_O, "delete_CPI(CPI self)"},
	 { "CPI_swigregister", CPI_swigregister, METH_O, NULL},
	 { "CPI_swiginit", CPI_swiginit, METH_VARARGS, NULL},
	 { "InflationCoupon_fixingDate", _wrap_InflationCoupon_fixingDate, METH_O, "InflationCoupon_fixingDate(InflationCoupon self) -> Date"},
	 { "InflationCoupon_fixingDays", _wrap_InflationCoupon_fixingDays, METH_O, "InflationCoupon_fixingDays(InflationCoupon self) -> Integer"},
	 { "InflationCoupon_observationLag", _wrap_InflationCoupon_observationLag, METH_O, "InflationCoupon_observationLag(InflationCoupon self) -> Period"},
	 { "InflationCoupon_indexFixing", _wrap_InflationCoupon_indexFixing, METH_O, "InflationCoupon_indexFixing(InflationCoupon self) -> Rate"},
	 { "InflationCoupon_index", _wrap_InflationCoupon_index, METH_O, "InflationCoupon_index(InflationCoupon self) -> ext::shared_ptr< InflationIndex >"},
	 { "delete_InflationCoupon", _wrap_delete_InflationCoupon, METH_O, "delete_InflationCoupon(InflationCoupon self)"},
	 { "InflationCoupon_swigregister", InflationCoupon_swigregister, METH_O, NULL},
	 { "as_inflation_coupon", _wrap_as_inflation_coupon, METH_O, "as_inflation_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< InflationCoupon >"},
	 { "new_CPICouponPricer", _wrap_new_CPICouponPricer, METH_NOARGS, "new_CPICouponPricer() -> CPICouponPricer"},
	 { "delete_CPICouponPricer", _wrap_delete_CPICouponPricer, METH_O, "delete_CPICouponPricer(CPICouponPricer self)"},
	 { "CPICouponPricer_swigregister", CPICouponPricer_swigregister, METH_O, NULL},
	 { "CPICouponPricer_swiginit", CPICouponPricer_swiginit, METH_VARARGS, NULL},
	 { "new_CPICoupon", _wrap_new_CPICoupon, METH_VARARGS, "\n"
		"CPICoupon(Real baseCPI, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date())\n"
		"CPICoupon(Date baseDate, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date())\n"
		"CPICoupon(Real baseCPI, Date baseDate, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date())\n"
		"CPICoupon(Real baseCPI, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Spread spread, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date())\n"
		"CPICoupon(Date baseDate, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Spread spread, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date())\n"
		"CPICoupon(Real baseCPI, Date baseDate, Date paymentDate, Real nominal, Date startDate, Date endDate, ext::shared_ptr< ZeroInflationIndex > const & index, Period observationLag, CPI::InterpolationType observationInterpolation, DayCounter dayCounter, Real fixedRate, Spread spread, Date refPeriodStart=Date(), Date refPeriodEnd=Date(), Date exCouponDate=Date())\n"
		""},
	 { "CPICoupon_fixedRate", _wrap_CPICoupon_fixedRate, METH_O, "CPICoupon_fixedRate(CPICoupon self) -> Rate"},
	 { "CPICoupon_spread", _wrap_CPICoupon_spread, METH_O, "CPICoupon_spread(CPICoupon self) -> Spread"},
	 { "CPICoupon_adjustedIndexGrowth", _wrap_CPICoupon_adjustedIndexGrowth, METH_O, "CPICoupon_adjustedIndexGrowth(CPICoupon self) -> Rate"},
	 { "CPICoupon_indexFixing", _wrap_CPICoupon_indexFixing, METH_O, "CPICoupon_indexFixing(CPICoupon self) -> Rate"},
	 { "CPICoupon_indexRatio", _wrap_CPICoupon_indexRatio, METH_VARARGS, "CPICoupon_indexRatio(CPICoupon self, Date d) -> Real"},
	 { "CPICoupon_baseCPI", _wrap_CPICoupon_baseCPI, METH_O, "CPICoupon_baseCPI(CPICoupon self) -> Rate"},
	 { "CPICoupon_baseDate", _wrap_CPICoupon_baseDate, METH_O, "CPICoupon_baseDate(CPICoupon self) -> Date"},
	 { "CPICoupon_observationInterpolation", _wrap_CPICoupon_observationInterpolation, METH_O, "CPICoupon_observationInterpolation(CPICoupon self) -> CPI::InterpolationType"},
	 { "CPICoupon_cpiIndex", _wrap_CPICoupon_cpiIndex, METH_O, "CPICoupon_cpiIndex(CPICoupon self) -> ext::shared_ptr< ZeroInflationIndex >"},
	 { "CPICoupon_setPricer", _wrap_CPICoupon_setPricer, METH_VARARGS, "CPICoupon_setPricer(CPICoupon self, ext::shared_ptr< CPICouponPricer > const & arg2)"},
	 { "delete_CPICoupon", _wrap_delete_CPICoupon, METH_O, "delete_CPICoupon(CPICoupon self)"},
	 { "CPICoupon_swigregister", CPICoupon_swigregister, METH_O, NULL},
	 { "CPICoupon_swiginit", CPICoupon_swiginit, METH_VARARGS, NULL},
	 { "as_cpi_coupon", _wrap_as_cpi_coupon, METH_O, "as_cpi_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< CPICoupon >"},
	 { "new_CPICashFlow", _wrap_new_CPICashFlow, METH_VARARGS, "CPICashFlow(Real notional, ext::shared_ptr< ZeroInflationIndex > const & index, Date baseDate, Real baseFixing, Date observationDate, Period observationLag, CPI::InterpolationType interpolation, Date paymentDate, bool growthOnly=False)"},
	 { "CPICashFlow_interpolation", _wrap_CPICashFlow_interpolation, METH_O, "CPICashFlow_interpolation(CPICashFlow self) -> CPI::InterpolationType"},
	 { "CPICashFlow_frequency", _wrap_CPICashFlow_frequency, METH_O, "CPICashFlow_frequency(CPICashFlow self) -> Frequency"},
	 { "delete_CPICashFlow", _wrap_delete_CPICashFlow, METH_O, "delete_CPICashFlow(CPICashFlow self)"},
	 { "CPICashFlow_swigregister", CPICashFlow_swigregister, METH_O, NULL},
	 { "CPICashFlow_swiginit", CPICashFlow_swiginit, METH_VARARGS, NULL},
	 { "as_cpi_cashflow", _wrap_as_cpi_cashflow, METH_O, "as_cpi_cashflow(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< CPICashFlow >"},
	 { "CPILeg", (PyCFunction)(void(*)(void))_wrap_CPILeg, METH_VARARGS|METH_KEYWORDS, "CPILeg(DoubleVector nominals, Schedule schedule, ext::shared_ptr< ZeroInflationIndex > const & index, Real baseCPI, Period observationLag, DayCounter paymentDayCounter=DayCounter(), BusinessDayConvention const paymentConvention=Following, DoubleVector fixedRates=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, Calendar paymentCalendar=Calendar(), bool growthOnly=True, CPI::InterpolationType observationInterpolation=AsIndex) -> Leg"},
	 { "new_ZeroInflationCashFlow", _wrap_new_ZeroInflationCashFlow, METH_VARARGS, "ZeroInflationCashFlow(Real notional, ext::shared_ptr< ZeroInflationIndex > const & index, CPI::InterpolationType observationInterpolation, Date startDate, Date endDate, Period observationLag, Date paymentDate, bool growthOnly=False)"},
	 { "ZeroInflationCashFlow_notional", _wrap_ZeroInflationCashFlow_notional, METH_O, "ZeroInflationCashFlow_notional(ZeroInflationCashFlow self) -> Real"},
	 { "ZeroInflationCashFlow_baseDate", _wrap_ZeroInflationCashFlow_baseDate, METH_O, "ZeroInflationCashFlow_baseDate(ZeroInflationCashFlow self) -> Date"},
	 { "ZeroInflationCashFlow_fixingDate", _wrap_ZeroInflationCashFlow_fixingDate, METH_O, "ZeroInflationCashFlow_fixingDate(ZeroInflationCashFlow self) -> Date"},
	 { "ZeroInflationCashFlow_growthOnly", _wrap_ZeroInflationCashFlow_growthOnly, METH_O, "ZeroInflationCashFlow_growthOnly(ZeroInflationCashFlow self) -> bool"},
	 { "ZeroInflationCashFlow_observationInterpolation", _wrap_ZeroInflationCashFlow_observationInterpolation, METH_O, "ZeroInflationCashFlow_observationInterpolation(ZeroInflationCashFlow self) -> CPI::InterpolationType"},
	 { "ZeroInflationCashFlow_zeroInflationIndex", _wrap_ZeroInflationCashFlow_zeroInflationIndex, METH_O, "ZeroInflationCashFlow_zeroInflationIndex(ZeroInflationCashFlow self) -> ext::shared_ptr< ZeroInflationIndex >"},
	 { "delete_ZeroInflationCashFlow", _wrap_delete_ZeroInflationCashFlow, METH_O, "delete_ZeroInflationCashFlow(ZeroInflationCashFlow self)"},
	 { "ZeroInflationCashFlow_swigregister", ZeroInflationCashFlow_swigregister, METH_O, NULL},
	 { "ZeroInflationCashFlow_swiginit", ZeroInflationCashFlow_swiginit, METH_VARARGS, NULL},
	 { "as_zero_inflation_cash_flow", _wrap_as_zero_inflation_cash_flow, METH_O, "as_zero_inflation_cash_flow(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< ZeroInflationCashFlow >"},
	 { "ZeroHelper_quote", _wrap_ZeroHelper_quote, METH_O, "ZeroHelper_quote(ZeroHelper self) -> QuoteHandle"},
	 { "ZeroHelper_latestDate", _wrap_ZeroHelper_latestDate, METH_O, "ZeroHelper_latestDate(ZeroHelper self) -> Date"},
	 { "ZeroHelper_earliestDate", _wrap_ZeroHelper_earliestDate, METH_O, "ZeroHelper_earliestDate(ZeroHelper self) -> Date"},
	 { "ZeroHelper_maturityDate", _wrap_ZeroHelper_maturityDate, METH_O, "ZeroHelper_maturityDate(ZeroHelper self) -> Date"},
	 { "ZeroHelper_latestRelevantDate", _wrap_ZeroHelper_latestRelevantDate, METH_O, "ZeroHelper_latestRelevantDate(ZeroHelper self) -> Date"},
	 { "ZeroHelper_pillarDate", _wrap_ZeroHelper_pillarDate, METH_O, "ZeroHelper_pillarDate(ZeroHelper self) -> Date"},
	 { "ZeroHelper_impliedQuote", _wrap_ZeroHelper_impliedQuote, METH_O, "ZeroHelper_impliedQuote(ZeroHelper self) -> Real"},
	 { "ZeroHelper_quoteError", _wrap_ZeroHelper_quoteError, METH_O, "ZeroHelper_quoteError(ZeroHelper self) -> Real"},
	 { "delete_ZeroHelper", _wrap_delete_ZeroHelper, METH_O, "delete_ZeroHelper(ZeroHelper self)"},
	 { "ZeroHelper_swigregister", ZeroHelper_swigregister, METH_O, NULL},
	 { "YoYHelper_quote", _wrap_YoYHelper_quote, METH_O, "YoYHelper_quote(YoYHelper self) -> QuoteHandle"},
	 { "YoYHelper_latestDate", _wrap_YoYHelper_latestDate, METH_O, "YoYHelper_latestDate(YoYHelper self) -> Date"},
	 { "YoYHelper_earliestDate", _wrap_YoYHelper_earliestDate, METH_O, "YoYHelper_earliestDate(YoYHelper self) -> Date"},
	 { "YoYHelper_maturityDate", _wrap_YoYHelper_maturityDate, METH_O, "YoYHelper_maturityDate(YoYHelper self) -> Date"},
	 { "YoYHelper_latestRelevantDate", _wrap_YoYHelper_latestRelevantDate, METH_O, "YoYHelper_latestRelevantDate(YoYHelper self) -> Date"},
	 { "YoYHelper_pillarDate", _wrap_YoYHelper_pillarDate, METH_O, "YoYHelper_pillarDate(YoYHelper self) -> Date"},
	 { "YoYHelper_impliedQuote", _wrap_YoYHelper_impliedQuote, METH_O, "YoYHelper_impliedQuote(YoYHelper self) -> Real"},
	 { "YoYHelper_quoteError", _wrap_YoYHelper_quoteError, METH_O, "YoYHelper_quoteError(YoYHelper self) -> Real"},
	 { "delete_YoYHelper", _wrap_delete_YoYHelper, METH_O, "delete_YoYHelper(YoYHelper self)"},
	 { "YoYHelper_swigregister", YoYHelper_swigregister, METH_O, NULL},
	 { "YoYOptionHelper_quote", _wrap_YoYOptionHelper_quote, METH_O, "YoYOptionHelper_quote(YoYOptionHelper self) -> QuoteHandle"},
	 { "YoYOptionHelper_latestDate", _wrap_YoYOptionHelper_latestDate, METH_O, "YoYOptionHelper_latestDate(YoYOptionHelper self) -> Date"},
	 { "YoYOptionHelper_earliestDate", _wrap_YoYOptionHelper_earliestDate, METH_O, "YoYOptionHelper_earliestDate(YoYOptionHelper self) -> Date"},
	 { "YoYOptionHelper_maturityDate", _wrap_YoYOptionHelper_maturityDate, METH_O, "YoYOptionHelper_maturityDate(YoYOptionHelper self) -> Date"},
	 { "YoYOptionHelper_latestRelevantDate", _wrap_YoYOptionHelper_latestRelevantDate, METH_O, "YoYOptionHelper_latestRelevantDate(YoYOptionHelper self) -> Date"},
	 { "YoYOptionHelper_pillarDate", _wrap_YoYOptionHelper_pillarDate, METH_O, "YoYOptionHelper_pillarDate(YoYOptionHelper self) -> Date"},
	 { "YoYOptionHelper_impliedQuote", _wrap_YoYOptionHelper_impliedQuote, METH_O, "YoYOptionHelper_impliedQuote(YoYOptionHelper self) -> Real"},
	 { "YoYOptionHelper_quoteError", _wrap_YoYOptionHelper_quoteError, METH_O, "YoYOptionHelper_quoteError(YoYOptionHelper self) -> Real"},
	 { "delete_YoYOptionHelper", _wrap_delete_YoYOptionHelper, METH_O, "delete_YoYOptionHelper(YoYOptionHelper self)"},
	 { "YoYOptionHelper_swigregister", YoYOptionHelper_swigregister, METH_O, NULL},
	 { "ZeroHelperVector_iterator", _wrap_ZeroHelperVector_iterator, METH_O, "ZeroHelperVector_iterator(ZeroHelperVector self) -> SwigPyIterator"},
	 { "ZeroHelperVector___nonzero__", _wrap_ZeroHelperVector___nonzero__, METH_O, "ZeroHelperVector___nonzero__(ZeroHelperVector self) -> bool"},
	 { "ZeroHelperVector___bool__", _wrap_ZeroHelperVector___bool__, METH_O, "ZeroHelperVector___bool__(ZeroHelperVector self) -> bool"},
	 { "ZeroHelperVector___len__", _wrap_ZeroHelperVector___len__, METH_O, "ZeroHelperVector___len__(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type"},
	 { "ZeroHelperVector___getslice__", _wrap_ZeroHelperVector___getslice__, METH_VARARGS, "ZeroHelperVector___getslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j) -> ZeroHelperVector"},
	 { "ZeroHelperVector___setslice__", _wrap_ZeroHelperVector___setslice__, METH_VARARGS, "\n"
		"ZeroHelperVector___setslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j)\n"
		"ZeroHelperVector___setslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j, ZeroHelperVector v)\n"
		""},
	 { "ZeroHelperVector___delslice__", _wrap_ZeroHelperVector___delslice__, METH_VARARGS, "ZeroHelperVector___delslice__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type j)"},
	 { "ZeroHelperVector___delitem__", _wrap_ZeroHelperVector___delitem__, METH_VARARGS, "\n"
		"ZeroHelperVector___delitem__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i)\n"
		"ZeroHelperVector___delitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "ZeroHelperVector___getitem__", _wrap_ZeroHelperVector___getitem__, METH_VARARGS, "\n"
		"ZeroHelperVector___getitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice) -> ZeroHelperVector\n"
		"ZeroHelperVector___getitem__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &\n"
		""},
	 { "ZeroHelperVector___setitem__", _wrap_ZeroHelperVector___setitem__, METH_VARARGS, "\n"
		"ZeroHelperVector___setitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice, ZeroHelperVector v)\n"
		"ZeroHelperVector___setitem__(ZeroHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"ZeroHelperVector___setitem__(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)\n"
		""},
	 { "ZeroHelperVector_pop", _wrap_ZeroHelperVector_pop, METH_O, "ZeroHelperVector_pop(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type"},
	 { "ZeroHelperVector_append", _wrap_ZeroHelperVector_append, METH_VARARGS, "ZeroHelperVector_append(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)"},
	 { "ZeroHelperVector_empty", _wrap_ZeroHelperVector_empty, METH_O, "ZeroHelperVector_empty(ZeroHelperVector self) -> bool"},
	 { "ZeroHelperVector_size", _wrap_ZeroHelperVector_size, METH_O, "ZeroHelperVector_size(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type"},
	 { "ZeroHelperVector_swap", _wrap_ZeroHelperVector_swap, METH_VARARGS, "ZeroHelperVector_swap(ZeroHelperVector self, ZeroHelperVector v)"},
	 { "ZeroHelperVector_begin", _wrap_ZeroHelperVector_begin, METH_O, "ZeroHelperVector_begin(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator"},
	 { "ZeroHelperVector_end", _wrap_ZeroHelperVector_end, METH_O, "ZeroHelperVector_end(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator"},
	 { "ZeroHelperVector_rbegin", _wrap_ZeroHelperVector_rbegin, METH_O, "ZeroHelperVector_rbegin(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator"},
	 { "ZeroHelperVector_rend", _wrap_ZeroHelperVector_rend, METH_O, "ZeroHelperVector_rend(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::reverse_iterator"},
	 { "ZeroHelperVector_clear", _wrap_ZeroHelperVector_clear, METH_O, "ZeroHelperVector_clear(ZeroHelperVector self)"},
	 { "ZeroHelperVector_get_allocator", _wrap_ZeroHelperVector_get_allocator, METH_O, "ZeroHelperVector_get_allocator(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::allocator_type"},
	 { "ZeroHelperVector_pop_back", _wrap_ZeroHelperVector_pop_back, METH_O, "ZeroHelperVector_pop_back(ZeroHelperVector self)"},
	 { "ZeroHelperVector_erase", _wrap_ZeroHelperVector_erase, METH_VARARGS, "\n"
		"ZeroHelperVector_erase(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator\n"
		"ZeroHelperVector_erase(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator first, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator last) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator\n"
		""},
	 { "new_ZeroHelperVector", _wrap_new_ZeroHelperVector, METH_VARARGS, "\n"
		"ZeroHelperVector()\n"
		"ZeroHelperVector(ZeroHelperVector other)\n"
		"ZeroHelperVector(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type size)\n"
		"new_ZeroHelperVector(std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type size, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & value) -> ZeroHelperVector\n"
		""},
	 { "ZeroHelperVector_push_back", _wrap_ZeroHelperVector_push_back, METH_VARARGS, "ZeroHelperVector_push_back(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)"},
	 { "ZeroHelperVector_front", _wrap_ZeroHelperVector_front, METH_O, "ZeroHelperVector_front(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &"},
	 { "ZeroHelperVector_back", _wrap_ZeroHelperVector_back, METH_O, "ZeroHelperVector_back(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const &"},
	 { "ZeroHelperVector_assign", _wrap_ZeroHelperVector_assign, METH_VARARGS, "ZeroHelperVector_assign(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)"},
	 { "ZeroHelperVector_resize", _wrap_ZeroHelperVector_resize, METH_VARARGS, "\n"
		"ZeroHelperVector_resize(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type new_size)\n"
		"ZeroHelperVector_resize(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type new_size, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)\n"
		""},
	 { "ZeroHelperVector_insert", _wrap_ZeroHelperVector_insert, METH_VARARGS, "\n"
		"ZeroHelperVector_insert(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator\n"
		"ZeroHelperVector_insert(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::value_type const & x)\n"
		""},
	 { "ZeroHelperVector_reserve", _wrap_ZeroHelperVector_reserve, METH_VARARGS, "ZeroHelperVector_reserve(ZeroHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type n)"},
	 { "ZeroHelperVector_capacity", _wrap_ZeroHelperVector_capacity, METH_O, "ZeroHelperVector_capacity(ZeroHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > >::size_type"},
	 { "delete_ZeroHelperVector", _wrap_delete_ZeroHelperVector, METH_O, "delete_ZeroHelperVector(ZeroHelperVector self)"},
	 { "ZeroHelperVector_swigregister", ZeroHelperVector_swigregister, METH_O, NULL},
	 { "ZeroHelperVector_swiginit", ZeroHelperVector_swiginit, METH_VARARGS, NULL},
	 { "YoYHelperVector_iterator", _wrap_YoYHelperVector_iterator, METH_O, "YoYHelperVector_iterator(YoYHelperVector self) -> SwigPyIterator"},
	 { "YoYHelperVector___nonzero__", _wrap_YoYHelperVector___nonzero__, METH_O, "YoYHelperVector___nonzero__(YoYHelperVector self) -> bool"},
	 { "YoYHelperVector___bool__", _wrap_YoYHelperVector___bool__, METH_O, "YoYHelperVector___bool__(YoYHelperVector self) -> bool"},
	 { "YoYHelperVector___len__", _wrap_YoYHelperVector___len__, METH_O, "YoYHelperVector___len__(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type"},
	 { "YoYHelperVector___getslice__", _wrap_YoYHelperVector___getslice__, METH_VARARGS, "YoYHelperVector___getslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j) -> YoYHelperVector"},
	 { "YoYHelperVector___setslice__", _wrap_YoYHelperVector___setslice__, METH_VARARGS, "\n"
		"YoYHelperVector___setslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j)\n"
		"YoYHelperVector___setslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j, YoYHelperVector v)\n"
		""},
	 { "YoYHelperVector___delslice__", _wrap_YoYHelperVector___delslice__, METH_VARARGS, "YoYHelperVector___delslice__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type j)"},
	 { "YoYHelperVector___delitem__", _wrap_YoYHelperVector___delitem__, METH_VARARGS, "\n"
		"YoYHelperVector___delitem__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i)\n"
		"YoYHelperVector___delitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "YoYHelperVector___getitem__", _wrap_YoYHelperVector___getitem__, METH_VARARGS, "\n"
		"YoYHelperVector___getitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice) -> YoYHelperVector\n"
		"YoYHelperVector___getitem__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &\n"
		""},
	 { "YoYHelperVector___setitem__", _wrap_YoYHelperVector___setitem__, METH_VARARGS, "\n"
		"YoYHelperVector___setitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice, YoYHelperVector v)\n"
		"YoYHelperVector___setitem__(YoYHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"YoYHelperVector___setitem__(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)\n"
		""},
	 { "YoYHelperVector_pop", _wrap_YoYHelperVector_pop, METH_O, "YoYHelperVector_pop(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type"},
	 { "YoYHelperVector_append", _wrap_YoYHelperVector_append, METH_VARARGS, "YoYHelperVector_append(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)"},
	 { "YoYHelperVector_empty", _wrap_YoYHelperVector_empty, METH_O, "YoYHelperVector_empty(YoYHelperVector self) -> bool"},
	 { "YoYHelperVector_size", _wrap_YoYHelperVector_size, METH_O, "YoYHelperVector_size(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type"},
	 { "YoYHelperVector_swap", _wrap_YoYHelperVector_swap, METH_VARARGS, "YoYHelperVector_swap(YoYHelperVector self, YoYHelperVector v)"},
	 { "YoYHelperVector_begin", _wrap_YoYHelperVector_begin, METH_O, "YoYHelperVector_begin(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator"},
	 { "YoYHelperVector_end", _wrap_YoYHelperVector_end, METH_O, "YoYHelperVector_end(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator"},
	 { "YoYHelperVector_rbegin", _wrap_YoYHelperVector_rbegin, METH_O, "YoYHelperVector_rbegin(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator"},
	 { "YoYHelperVector_rend", _wrap_YoYHelperVector_rend, METH_O, "YoYHelperVector_rend(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::reverse_iterator"},
	 { "YoYHelperVector_clear", _wrap_YoYHelperVector_clear, METH_O, "YoYHelperVector_clear(YoYHelperVector self)"},
	 { "YoYHelperVector_get_allocator", _wrap_YoYHelperVector_get_allocator, METH_O, "YoYHelperVector_get_allocator(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::allocator_type"},
	 { "YoYHelperVector_pop_back", _wrap_YoYHelperVector_pop_back, METH_O, "YoYHelperVector_pop_back(YoYHelperVector self)"},
	 { "YoYHelperVector_erase", _wrap_YoYHelperVector_erase, METH_VARARGS, "\n"
		"YoYHelperVector_erase(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator\n"
		"YoYHelperVector_erase(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator first, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator last) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator\n"
		""},
	 { "new_YoYHelperVector", _wrap_new_YoYHelperVector, METH_VARARGS, "\n"
		"YoYHelperVector()\n"
		"YoYHelperVector(YoYHelperVector other)\n"
		"YoYHelperVector(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type size)\n"
		"new_YoYHelperVector(std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type size, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & value) -> YoYHelperVector\n"
		""},
	 { "YoYHelperVector_push_back", _wrap_YoYHelperVector_push_back, METH_VARARGS, "YoYHelperVector_push_back(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)"},
	 { "YoYHelperVector_front", _wrap_YoYHelperVector_front, METH_O, "YoYHelperVector_front(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &"},
	 { "YoYHelperVector_back", _wrap_YoYHelperVector_back, METH_O, "YoYHelperVector_back(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const &"},
	 { "YoYHelperVector_assign", _wrap_YoYHelperVector_assign, METH_VARARGS, "YoYHelperVector_assign(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)"},
	 { "YoYHelperVector_resize", _wrap_YoYHelperVector_resize, METH_VARARGS, "\n"
		"YoYHelperVector_resize(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type new_size)\n"
		"YoYHelperVector_resize(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type new_size, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)\n"
		""},
	 { "YoYHelperVector_insert", _wrap_YoYHelperVector_insert, METH_VARARGS, "\n"
		"YoYHelperVector_insert(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator\n"
		"YoYHelperVector_insert(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::value_type const & x)\n"
		""},
	 { "YoYHelperVector_reserve", _wrap_YoYHelperVector_reserve, METH_VARARGS, "YoYHelperVector_reserve(YoYHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type n)"},
	 { "YoYHelperVector_capacity", _wrap_YoYHelperVector_capacity, METH_O, "YoYHelperVector_capacity(YoYHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > >::size_type"},
	 { "delete_YoYHelperVector", _wrap_delete_YoYHelperVector, METH_O, "delete_YoYHelperVector(YoYHelperVector self)"},
	 { "YoYHelperVector_swigregister", YoYHelperVector_swigregister, METH_O, NULL},
	 { "YoYHelperVector_swiginit", YoYHelperVector_swiginit, METH_VARARGS, NULL},
	 { "YoYOptionHelperVector_iterator", _wrap_YoYOptionHelperVector_iterator, METH_O, "YoYOptionHelperVector_iterator(YoYOptionHelperVector self) -> SwigPyIterator"},
	 { "YoYOptionHelperVector___nonzero__", _wrap_YoYOptionHelperVector___nonzero__, METH_O, "YoYOptionHelperVector___nonzero__(YoYOptionHelperVector self) -> bool"},
	 { "YoYOptionHelperVector___bool__", _wrap_YoYOptionHelperVector___bool__, METH_O, "YoYOptionHelperVector___bool__(YoYOptionHelperVector self) -> bool"},
	 { "YoYOptionHelperVector___len__", _wrap_YoYOptionHelperVector___len__, METH_O, "YoYOptionHelperVector___len__(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type"},
	 { "YoYOptionHelperVector___getslice__", _wrap_YoYOptionHelperVector___getslice__, METH_VARARGS, "YoYOptionHelperVector___getslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j) -> YoYOptionHelperVector"},
	 { "YoYOptionHelperVector___setslice__", _wrap_YoYOptionHelperVector___setslice__, METH_VARARGS, "\n"
		"YoYOptionHelperVector___setslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j)\n"
		"YoYOptionHelperVector___setslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j, YoYOptionHelperVector v)\n"
		""},
	 { "YoYOptionHelperVector___delslice__", _wrap_YoYOptionHelperVector___delslice__, METH_VARARGS, "YoYOptionHelperVector___delslice__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type j)"},
	 { "YoYOptionHelperVector___delitem__", _wrap_YoYOptionHelperVector___delitem__, METH_VARARGS, "\n"
		"YoYOptionHelperVector___delitem__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i)\n"
		"YoYOptionHelperVector___delitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "YoYOptionHelperVector___getitem__", _wrap_YoYOptionHelperVector___getitem__, METH_VARARGS, "\n"
		"YoYOptionHelperVector___getitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice) -> YoYOptionHelperVector\n"
		"YoYOptionHelperVector___getitem__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &\n"
		""},
	 { "YoYOptionHelperVector___setitem__", _wrap_YoYOptionHelperVector___setitem__, METH_VARARGS, "\n"
		"YoYOptionHelperVector___setitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice, YoYOptionHelperVector v)\n"
		"YoYOptionHelperVector___setitem__(YoYOptionHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"YoYOptionHelperVector___setitem__(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::difference_type i, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)\n"
		""},
	 { "YoYOptionHelperVector_pop", _wrap_YoYOptionHelperVector_pop, METH_O, "YoYOptionHelperVector_pop(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type"},
	 { "YoYOptionHelperVector_append", _wrap_YoYOptionHelperVector_append, METH_VARARGS, "YoYOptionHelperVector_append(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)"},
	 { "YoYOptionHelperVector_empty", _wrap_YoYOptionHelperVector_empty, METH_O, "YoYOptionHelperVector_empty(YoYOptionHelperVector self) -> bool"},
	 { "YoYOptionHelperVector_size", _wrap_YoYOptionHelperVector_size, METH_O, "YoYOptionHelperVector_size(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type"},
	 { "YoYOptionHelperVector_swap", _wrap_YoYOptionHelperVector_swap, METH_VARARGS, "YoYOptionHelperVector_swap(YoYOptionHelperVector self, YoYOptionHelperVector v)"},
	 { "YoYOptionHelperVector_begin", _wrap_YoYOptionHelperVector_begin, METH_O, "YoYOptionHelperVector_begin(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator"},
	 { "YoYOptionHelperVector_end", _wrap_YoYOptionHelperVector_end, METH_O, "YoYOptionHelperVector_end(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator"},
	 { "YoYOptionHelperVector_rbegin", _wrap_YoYOptionHelperVector_rbegin, METH_O, "YoYOptionHelperVector_rbegin(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator"},
	 { "YoYOptionHelperVector_rend", _wrap_YoYOptionHelperVector_rend, METH_O, "YoYOptionHelperVector_rend(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::reverse_iterator"},
	 { "YoYOptionHelperVector_clear", _wrap_YoYOptionHelperVector_clear, METH_O, "YoYOptionHelperVector_clear(YoYOptionHelperVector self)"},
	 { "YoYOptionHelperVector_get_allocator", _wrap_YoYOptionHelperVector_get_allocator, METH_O, "YoYOptionHelperVector_get_allocator(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::allocator_type"},
	 { "YoYOptionHelperVector_pop_back", _wrap_YoYOptionHelperVector_pop_back, METH_O, "YoYOptionHelperVector_pop_back(YoYOptionHelperVector self)"},
	 { "YoYOptionHelperVector_erase", _wrap_YoYOptionHelperVector_erase, METH_VARARGS, "\n"
		"YoYOptionHelperVector_erase(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator\n"
		"YoYOptionHelperVector_erase(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator first, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator last) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator\n"
		""},
	 { "new_YoYOptionHelperVector", _wrap_new_YoYOptionHelperVector, METH_VARARGS, "\n"
		"YoYOptionHelperVector()\n"
		"YoYOptionHelperVector(YoYOptionHelperVector other)\n"
		"YoYOptionHelperVector(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type size)\n"
		"new_YoYOptionHelperVector(std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type size, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & value) -> YoYOptionHelperVector\n"
		""},
	 { "YoYOptionHelperVector_push_back", _wrap_YoYOptionHelperVector_push_back, METH_VARARGS, "YoYOptionHelperVector_push_back(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)"},
	 { "YoYOptionHelperVector_front", _wrap_YoYOptionHelperVector_front, METH_O, "YoYOptionHelperVector_front(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &"},
	 { "YoYOptionHelperVector_back", _wrap_YoYOptionHelperVector_back, METH_O, "YoYOptionHelperVector_back(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const &"},
	 { "YoYOptionHelperVector_assign", _wrap_YoYOptionHelperVector_assign, METH_VARARGS, "YoYOptionHelperVector_assign(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)"},
	 { "YoYOptionHelperVector_resize", _wrap_YoYOptionHelperVector_resize, METH_VARARGS, "\n"
		"YoYOptionHelperVector_resize(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type new_size)\n"
		"YoYOptionHelperVector_resize(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type new_size, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)\n"
		""},
	 { "YoYOptionHelperVector_insert", _wrap_YoYOptionHelperVector_insert, METH_VARARGS, "\n"
		"YoYOptionHelperVector_insert(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator\n"
		"YoYOptionHelperVector_insert(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::iterator pos, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::value_type const & x)\n"
		""},
	 { "YoYOptionHelperVector_reserve", _wrap_YoYOptionHelperVector_reserve, METH_VARARGS, "YoYOptionHelperVector_reserve(YoYOptionHelperVector self, std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type n)"},
	 { "YoYOptionHelperVector_capacity", _wrap_YoYOptionHelperVector_capacity, METH_O, "YoYOptionHelperVector_capacity(YoYOptionHelperVector self) -> std::vector< ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > >::size_type"},
	 { "delete_YoYOptionHelperVector", _wrap_delete_YoYOptionHelperVector, METH_O, "delete_YoYOptionHelperVector(YoYOptionHelperVector self)"},
	 { "YoYOptionHelperVector_swigregister", YoYOptionHelperVector_swigregister, METH_O, NULL},
	 { "YoYOptionHelperVector_swiginit", YoYOptionHelperVector_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroCouponInflationSwapHelper", _wrap_new_ZeroCouponInflationSwapHelper, METH_VARARGS, "new_ZeroCouponInflationSwapHelper(QuoteHandle quote, Period lag, Date maturity, Calendar calendar, BusinessDayConvention bcd, DayCounter dayCounter, ext::shared_ptr< ZeroInflationIndex > const & index, CPI::InterpolationType observationInterpolation, YieldTermStructureHandle nominalTS) -> ZeroCouponInflationSwapHelper"},
	 { "delete_ZeroCouponInflationSwapHelper", _wrap_delete_ZeroCouponInflationSwapHelper, METH_O, "delete_ZeroCouponInflationSwapHelper(ZeroCouponInflationSwapHelper self)"},
	 { "ZeroCouponInflationSwapHelper_swigregister", ZeroCouponInflationSwapHelper_swigregister, METH_O, NULL},
	 { "ZeroCouponInflationSwapHelper_swiginit", ZeroCouponInflationSwapHelper_swiginit, METH_VARARGS, NULL},
	 { "new_YearOnYearInflationSwapHelper", _wrap_new_YearOnYearInflationSwapHelper, METH_VARARGS, "new_YearOnYearInflationSwapHelper(QuoteHandle quote, Period lag, Date maturity, Calendar calendar, BusinessDayConvention bdc, DayCounter dayCounter, ext::shared_ptr< YoYInflationIndex > const & index, YieldTermStructureHandle nominalTS) -> YearOnYearInflationSwapHelper"},
	 { "delete_YearOnYearInflationSwapHelper", _wrap_delete_YearOnYearInflationSwapHelper, METH_O, "delete_YearOnYearInflationSwapHelper(YearOnYearInflationSwapHelper self)"},
	 { "YearOnYearInflationSwapHelper_swigregister", YearOnYearInflationSwapHelper_swigregister, METH_O, NULL},
	 { "YearOnYearInflationSwapHelper_swiginit", YearOnYearInflationSwapHelper_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseZeroInflation", _wrap_new_PiecewiseZeroInflation, METH_VARARGS, "PiecewiseZeroInflation(Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, Rate baseRate, ZeroHelperVector instruments, Real accuracy=1.0e-12, Linear i=Linear())"},
	 { "PiecewiseZeroInflation_dates", _wrap_PiecewiseZeroInflation_dates, METH_O, "PiecewiseZeroInflation_dates(PiecewiseZeroInflation self) -> DateVector"},
	 { "PiecewiseZeroInflation_times", _wrap_PiecewiseZeroInflation_times, METH_O, "PiecewiseZeroInflation_times(PiecewiseZeroInflation self) -> DoubleVector"},
	 { "PiecewiseZeroInflation_nodes", _wrap_PiecewiseZeroInflation_nodes, METH_O, "PiecewiseZeroInflation_nodes(PiecewiseZeroInflation self) -> NodeVector"},
	 { "delete_PiecewiseZeroInflation", _wrap_delete_PiecewiseZeroInflation, METH_O, "delete_PiecewiseZeroInflation(PiecewiseZeroInflation self)"},
	 { "PiecewiseZeroInflation_swigregister", PiecewiseZeroInflation_swigregister, METH_O, NULL},
	 { "PiecewiseZeroInflation_swiginit", PiecewiseZeroInflation_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseYoYInflation", (PyCFunction)(void(*)(void))_wrap_new_PiecewiseYoYInflation, METH_VARARGS|METH_KEYWORDS, "new_PiecewiseYoYInflation(Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, bool indexIsInterpolated, Rate baseRate, YoYHelperVector instruments, Real accuracy=1.0e-12, Linear i=Linear()) -> PiecewiseYoYInflation"},
	 { "PiecewiseYoYInflation_dates", _wrap_PiecewiseYoYInflation_dates, METH_O, "PiecewiseYoYInflation_dates(PiecewiseYoYInflation self) -> DateVector"},
	 { "PiecewiseYoYInflation_times", _wrap_PiecewiseYoYInflation_times, METH_O, "PiecewiseYoYInflation_times(PiecewiseYoYInflation self) -> DoubleVector"},
	 { "PiecewiseYoYInflation_nodes", _wrap_PiecewiseYoYInflation_nodes, METH_O, "PiecewiseYoYInflation_nodes(PiecewiseYoYInflation self) -> NodeVector"},
	 { "delete_PiecewiseYoYInflation", _wrap_delete_PiecewiseYoYInflation, METH_O, "delete_PiecewiseYoYInflation(PiecewiseYoYInflation self)"},
	 { "PiecewiseYoYInflation_swigregister", PiecewiseYoYInflation_swigregister, METH_O, NULL},
	 { "PiecewiseYoYInflation_swiginit", PiecewiseYoYInflation_swiginit, METH_VARARGS, NULL},
	 { "new_DatePair", _wrap_new_DatePair, METH_VARARGS, "\n"
		"DatePair()\n"
		"DatePair(Date first, Date second)\n"
		"new_DatePair(DatePair other) -> DatePair\n"
		""},
	 { "DatePair_first_set", _wrap_DatePair_first_set, METH_VARARGS, "DatePair_first_set(DatePair self, Date first)"},
	 { "DatePair_first_get", _wrap_DatePair_first_get, METH_O, "DatePair_first_get(DatePair self) -> Date"},
	 { "DatePair_second_set", _wrap_DatePair_second_set, METH_VARARGS, "DatePair_second_set(DatePair self, Date second)"},
	 { "DatePair_second_get", _wrap_DatePair_second_get, METH_O, "DatePair_second_get(DatePair self) -> Date"},
	 { "delete_DatePair", _wrap_delete_DatePair, METH_O, "delete_DatePair(DatePair self)"},
	 { "DatePair_swigregister", DatePair_swigregister, METH_O, NULL},
	 { "DatePair_swiginit", DatePair_swiginit, METH_VARARGS, NULL},
	 { "inflationPeriod", _wrap_inflationPeriod, METH_VARARGS, "inflationPeriod(Date d, Frequency f) -> DatePair"},
	 { "inflationYearFraction", _wrap_inflationYearFraction, METH_VARARGS, "inflationYearFraction(Frequency f, bool indexIsInterpolated, DayCounter dayCount, Date d1, Date d2) -> Time"},
	 { "inflationBaseDate", _wrap_inflationBaseDate, METH_VARARGS, "inflationBaseDate(Date referenceDate, Period observationLag, Frequency frequency, bool indexIsInterpolated) -> Date"},
	 { "delete_YoYInflationCouponPricer", _wrap_delete_YoYInflationCouponPricer, METH_O, "delete_YoYInflationCouponPricer(YoYInflationCouponPricer self)"},
	 { "YoYInflationCouponPricer_swigregister", YoYInflationCouponPricer_swigregister, METH_O, NULL},
	 { "setCouponPricer", _wrap_setCouponPricer, METH_VARARGS, "\n"
		"setCouponPricer(Leg arg1, ext::shared_ptr< FloatingRateCouponPricer > const & arg2)\n"
		"setCouponPricer(Leg arg1, ext::shared_ptr< EquityCashFlowPricer > const & arg2)\n"
		"setCouponPricer(Leg arg1, ext::shared_ptr< YoYInflationCouponPricer > const & arg2)\n"
		""},
	 { "new_YoYInflationCoupon", _wrap_new_YoYInflationCoupon, METH_VARARGS, "YoYInflationCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< YoYInflationIndex > const & index, Period observationLag, DayCounter dayCounter, Real gearing=1.0, Spread spread=0.0, Date refPeriodStart=Date(), Date refPeriodEnd=Date())"},
	 { "YoYInflationCoupon_gearing", _wrap_YoYInflationCoupon_gearing, METH_O, "YoYInflationCoupon_gearing(YoYInflationCoupon self) -> Real"},
	 { "YoYInflationCoupon_spread", _wrap_YoYInflationCoupon_spread, METH_O, "YoYInflationCoupon_spread(YoYInflationCoupon self) -> Spread"},
	 { "YoYInflationCoupon_adjustedFixing", _wrap_YoYInflationCoupon_adjustedFixing, METH_O, "YoYInflationCoupon_adjustedFixing(YoYInflationCoupon self) -> Rate"},
	 { "YoYInflationCoupon_yoyIndex", _wrap_YoYInflationCoupon_yoyIndex, METH_O, "YoYInflationCoupon_yoyIndex(YoYInflationCoupon self) -> ext::shared_ptr< YoYInflationIndex >"},
	 { "delete_YoYInflationCoupon", _wrap_delete_YoYInflationCoupon, METH_O, "delete_YoYInflationCoupon(YoYInflationCoupon self)"},
	 { "YoYInflationCoupon_swigregister", YoYInflationCoupon_swigregister, METH_O, NULL},
	 { "YoYInflationCoupon_swiginit", YoYInflationCoupon_swiginit, METH_VARARGS, NULL},
	 { "as_yoy_inflation_coupon", _wrap_as_yoy_inflation_coupon, METH_O, "as_yoy_inflation_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< YoYInflationCoupon >"},
	 { "new_CappedFlooredYoYInflationCoupon", _wrap_new_CappedFlooredYoYInflationCoupon, METH_VARARGS, "CappedFlooredYoYInflationCoupon(Date paymentDate, Real nominal, Date startDate, Date endDate, Natural fixingDays, ext::shared_ptr< YoYInflationIndex > const & index, Period observationLag, DayCounter dayCounter, Real gearing=1.0, Spread spread=0.0, Rate const cap=Null< Rate >(), Rate const floor=Null< Rate >(), Date refPeriodStart=Date(), Date refPeriodEnd=Date())"},
	 { "CappedFlooredYoYInflationCoupon_rate", _wrap_CappedFlooredYoYInflationCoupon_rate, METH_O, "CappedFlooredYoYInflationCoupon_rate(CappedFlooredYoYInflationCoupon self) -> Rate"},
	 { "CappedFlooredYoYInflationCoupon_cap", _wrap_CappedFlooredYoYInflationCoupon_cap, METH_O, "CappedFlooredYoYInflationCoupon_cap(CappedFlooredYoYInflationCoupon self) -> Rate"},
	 { "CappedFlooredYoYInflationCoupon_floor", _wrap_CappedFlooredYoYInflationCoupon_floor, METH_O, "CappedFlooredYoYInflationCoupon_floor(CappedFlooredYoYInflationCoupon self) -> Rate"},
	 { "CappedFlooredYoYInflationCoupon_effectiveCap", _wrap_CappedFlooredYoYInflationCoupon_effectiveCap, METH_O, "CappedFlooredYoYInflationCoupon_effectiveCap(CappedFlooredYoYInflationCoupon self) -> Rate"},
	 { "CappedFlooredYoYInflationCoupon_effectiveFloor", _wrap_CappedFlooredYoYInflationCoupon_effectiveFloor, METH_O, "CappedFlooredYoYInflationCoupon_effectiveFloor(CappedFlooredYoYInflationCoupon self) -> Rate"},
	 { "CappedFlooredYoYInflationCoupon_underlyingRate", _wrap_CappedFlooredYoYInflationCoupon_underlyingRate, METH_O, "CappedFlooredYoYInflationCoupon_underlyingRate(CappedFlooredYoYInflationCoupon self) -> Rate"},
	 { "CappedFlooredYoYInflationCoupon_isCapped", _wrap_CappedFlooredYoYInflationCoupon_isCapped, METH_O, "CappedFlooredYoYInflationCoupon_isCapped(CappedFlooredYoYInflationCoupon self) -> bool"},
	 { "CappedFlooredYoYInflationCoupon_isFloored", _wrap_CappedFlooredYoYInflationCoupon_isFloored, METH_O, "CappedFlooredYoYInflationCoupon_isFloored(CappedFlooredYoYInflationCoupon self) -> bool"},
	 { "delete_CappedFlooredYoYInflationCoupon", _wrap_delete_CappedFlooredYoYInflationCoupon, METH_O, "delete_CappedFlooredYoYInflationCoupon(CappedFlooredYoYInflationCoupon self)"},
	 { "CappedFlooredYoYInflationCoupon_swigregister", CappedFlooredYoYInflationCoupon_swigregister, METH_O, NULL},
	 { "CappedFlooredYoYInflationCoupon_swiginit", CappedFlooredYoYInflationCoupon_swiginit, METH_VARARGS, NULL},
	 { "as_capped_floored_yoy_inflation_coupon", _wrap_as_capped_floored_yoy_inflation_coupon, METH_O, "as_capped_floored_yoy_inflation_coupon(ext::shared_ptr< CashFlow > const & cf) -> ext::shared_ptr< CappedFlooredYoYInflationCoupon >"},
	 { "yoyInflationLeg", (PyCFunction)(void(*)(void))_wrap_yoyInflationLeg, METH_VARARGS|METH_KEYWORDS, "yoyInflationLeg(Schedule schedule, Calendar calendar, ext::shared_ptr< YoYInflationIndex > const & index, Period observationLag, DoubleVector notionals, DayCounter paymentDayCounter, BusinessDayConvention paymentAdjustment=Following, Natural fixingDays=0, DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >()) -> Leg"},
	 { "new_BlackYoYInflationCouponPricer", _wrap_new_BlackYoYInflationCouponPricer, METH_VARARGS, "new_BlackYoYInflationCouponPricer(YoYOptionletVolatilitySurfaceHandle capletVol, YieldTermStructureHandle nominalTermStructure) -> BlackYoYInflationCouponPricer"},
	 { "delete_BlackYoYInflationCouponPricer", _wrap_delete_BlackYoYInflationCouponPricer, METH_O, "delete_BlackYoYInflationCouponPricer(BlackYoYInflationCouponPricer self)"},
	 { "BlackYoYInflationCouponPricer_swigregister", BlackYoYInflationCouponPricer_swigregister, METH_O, NULL},
	 { "BlackYoYInflationCouponPricer_swiginit", BlackYoYInflationCouponPricer_swiginit, METH_VARARGS, NULL},
	 { "new_UnitDisplacedBlackYoYInflationCouponPricer", _wrap_new_UnitDisplacedBlackYoYInflationCouponPricer, METH_VARARGS, "new_UnitDisplacedBlackYoYInflationCouponPricer(YoYOptionletVolatilitySurfaceHandle capletVol, YieldTermStructureHandle nominalTermStructure) -> UnitDisplacedBlackYoYInflationCouponPricer"},
	 { "delete_UnitDisplacedBlackYoYInflationCouponPricer", _wrap_delete_UnitDisplacedBlackYoYInflationCouponPricer, METH_O, "delete_UnitDisplacedBlackYoYInflationCouponPricer(UnitDisplacedBlackYoYInflationCouponPricer self)"},
	 { "UnitDisplacedBlackYoYInflationCouponPricer_swigregister", UnitDisplacedBlackYoYInflationCouponPricer_swigregister, METH_O, NULL},
	 { "UnitDisplacedBlackYoYInflationCouponPricer_swiginit", UnitDisplacedBlackYoYInflationCouponPricer_swiginit, METH_VARARGS, NULL},
	 { "new_BachelierYoYInflationCouponPricer", _wrap_new_BachelierYoYInflationCouponPricer, METH_VARARGS, "new_BachelierYoYInflationCouponPricer(YoYOptionletVolatilitySurfaceHandle capletVol, YieldTermStructureHandle nominalTermStructure) -> BachelierYoYInflationCouponPricer"},
	 { "delete_BachelierYoYInflationCouponPricer", _wrap_delete_BachelierYoYInflationCouponPricer, METH_O, "delete_BachelierYoYInflationCouponPricer(BachelierYoYInflationCouponPricer self)"},
	 { "BachelierYoYInflationCouponPricer_swigregister", BachelierYoYInflationCouponPricer_swigregister, METH_O, NULL},
	 { "BachelierYoYInflationCouponPricer_swiginit", BachelierYoYInflationCouponPricer_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroCouponInflationSwap", _wrap_new_ZeroCouponInflationSwap, METH_VARARGS, "ZeroCouponInflationSwap(Swap::Type type, Real nominal, Date start, Date maturity, Calendar calendar, BusinessDayConvention convention, DayCounter dayCounter, Rate fixedRate, ext::shared_ptr< ZeroInflationIndex > const & index, Period lag, CPI::InterpolationType observationInterpolation, bool adjustInfObsDates=False, Calendar infCalendar=Calendar(), BusinessDayConvention infConvention=BusinessDayConvention())"},
	 { "ZeroCouponInflationSwap_fairRate", _wrap_ZeroCouponInflationSwap_fairRate, METH_O, "ZeroCouponInflationSwap_fairRate(ZeroCouponInflationSwap self) -> Rate"},
	 { "ZeroCouponInflationSwap_fixedLegNPV", _wrap_ZeroCouponInflationSwap_fixedLegNPV, METH_O, "ZeroCouponInflationSwap_fixedLegNPV(ZeroCouponInflationSwap self) -> Real"},
	 { "ZeroCouponInflationSwap_inflationLegNPV", _wrap_ZeroCouponInflationSwap_inflationLegNPV, METH_O, "ZeroCouponInflationSwap_inflationLegNPV(ZeroCouponInflationSwap self) -> Real"},
	 { "ZeroCouponInflationSwap_fixedLeg", _wrap_ZeroCouponInflationSwap_fixedLeg, METH_O, "ZeroCouponInflationSwap_fixedLeg(ZeroCouponInflationSwap self) -> Leg"},
	 { "ZeroCouponInflationSwap_inflationLeg", _wrap_ZeroCouponInflationSwap_inflationLeg, METH_O, "ZeroCouponInflationSwap_inflationLeg(ZeroCouponInflationSwap self) -> Leg"},
	 { "ZeroCouponInflationSwap_type", _wrap_ZeroCouponInflationSwap_type, METH_O, "ZeroCouponInflationSwap_type(ZeroCouponInflationSwap self) -> Swap::Type"},
	 { "delete_ZeroCouponInflationSwap", _wrap_delete_ZeroCouponInflationSwap, METH_O, "delete_ZeroCouponInflationSwap(ZeroCouponInflationSwap self)"},
	 { "ZeroCouponInflationSwap_swigregister", ZeroCouponInflationSwap_swigregister, METH_O, NULL},
	 { "ZeroCouponInflationSwap_swiginit", ZeroCouponInflationSwap_swiginit, METH_VARARGS, NULL},
	 { "new_YearOnYearInflationSwap", _wrap_new_YearOnYearInflationSwap, METH_VARARGS, "YearOnYearInflationSwap(Swap::Type type, Real nominal, Schedule fixedSchedule, Rate fixedRate, DayCounter fixedDayCounter, Schedule yoySchedule, ext::shared_ptr< YoYInflationIndex > const & index, Period lag, Spread spread, DayCounter yoyDayCounter, Calendar paymentCalendar, BusinessDayConvention paymentConvention=Following)"},
	 { "YearOnYearInflationSwap_fairRate", _wrap_YearOnYearInflationSwap_fairRate, METH_O, "YearOnYearInflationSwap_fairRate(YearOnYearInflationSwap self) -> Rate"},
	 { "YearOnYearInflationSwap_fixedLegNPV", _wrap_YearOnYearInflationSwap_fixedLegNPV, METH_O, "YearOnYearInflationSwap_fixedLegNPV(YearOnYearInflationSwap self) -> Real"},
	 { "YearOnYearInflationSwap_yoyLegNPV", _wrap_YearOnYearInflationSwap_yoyLegNPV, METH_O, "YearOnYearInflationSwap_yoyLegNPV(YearOnYearInflationSwap self) -> Real"},
	 { "YearOnYearInflationSwap_fairSpread", _wrap_YearOnYearInflationSwap_fairSpread, METH_O, "YearOnYearInflationSwap_fairSpread(YearOnYearInflationSwap self) -> Spread"},
	 { "YearOnYearInflationSwap_fixedLeg", _wrap_YearOnYearInflationSwap_fixedLeg, METH_O, "YearOnYearInflationSwap_fixedLeg(YearOnYearInflationSwap self) -> Leg"},
	 { "YearOnYearInflationSwap_yoyLeg", _wrap_YearOnYearInflationSwap_yoyLeg, METH_O, "YearOnYearInflationSwap_yoyLeg(YearOnYearInflationSwap self) -> Leg"},
	 { "delete_YearOnYearInflationSwap", _wrap_delete_YearOnYearInflationSwap, METH_O, "delete_YearOnYearInflationSwap(YearOnYearInflationSwap self)"},
	 { "YearOnYearInflationSwap_swigregister", YearOnYearInflationSwap_swigregister, METH_O, NULL},
	 { "YearOnYearInflationSwap_swiginit", YearOnYearInflationSwap_swiginit, METH_VARARGS, NULL},
	 { "new_CPISwap", _wrap_new_CPISwap, METH_VARARGS, "CPISwap(Swap::Type type, Real nominal, bool subtractInflationNominal, Spread spread, DayCounter floatDayCount, Schedule floatSchedule, BusinessDayConvention const & floatRoll, Natural fixingDays, ext::shared_ptr< IborIndex > const & floatIndex, Rate fixedRate, Real baseCPI, DayCounter fixedDayCount, Schedule fixedSchedule, BusinessDayConvention const & fixedRoll, Period observationLag, ext::shared_ptr< ZeroInflationIndex > const & fixedIndex, CPI::InterpolationType observationInterpolation=AsIndex, Real inflationNominal=Null< Real >())"},
	 { "CPISwap_fairRate", _wrap_CPISwap_fairRate, METH_O, "CPISwap_fairRate(CPISwap self) -> Rate"},
	 { "CPISwap_floatLegNPV", _wrap_CPISwap_floatLegNPV, METH_O, "CPISwap_floatLegNPV(CPISwap self) -> Real"},
	 { "CPISwap_fairSpread", _wrap_CPISwap_fairSpread, METH_O, "CPISwap_fairSpread(CPISwap self) -> Spread"},
	 { "CPISwap_fixedLegNPV", _wrap_CPISwap_fixedLegNPV, METH_O, "CPISwap_fixedLegNPV(CPISwap self) -> Real"},
	 { "CPISwap_cpiLeg", _wrap_CPISwap_cpiLeg, METH_O, "CPISwap_cpiLeg(CPISwap self) -> Leg"},
	 { "CPISwap_floatLeg", _wrap_CPISwap_floatLeg, METH_O, "CPISwap_floatLeg(CPISwap self) -> Leg"},
	 { "delete_CPISwap", _wrap_delete_CPISwap, METH_O, "delete_CPISwap(CPISwap self)"},
	 { "CPISwap_swigregister", CPISwap_swigregister, METH_O, NULL},
	 { "CPISwap_swiginit", CPISwap_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCapFloor", _wrap_new_YoYInflationCapFloor, METH_VARARGS, "new_YoYInflationCapFloor(YoYInflationCapFloor::Type type, Leg yoyLeg, DoubleVector strikes) -> YoYInflationCapFloor"},
	 { "YoYInflationCapFloor_impliedVolatility", _wrap_YoYInflationCapFloor_impliedVolatility, METH_VARARGS, "YoYInflationCapFloor_impliedVolatility(YoYInflationCapFloor self, Real price, YoYInflationTermStructureHandle curve, Volatility guess, Real accuracy=1.0e-4, Size maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0) -> Volatility"},
	 { "YoYInflationCapFloor_optionletPrices", _wrap_YoYInflationCapFloor_optionletPrices, METH_O, "YoYInflationCapFloor_optionletPrices(YoYInflationCapFloor self) -> DoubleVector"},
	 { "delete_YoYInflationCapFloor", _wrap_delete_YoYInflationCapFloor, METH_O, "delete_YoYInflationCapFloor(YoYInflationCapFloor self)"},
	 { "YoYInflationCapFloor_swigregister", YoYInflationCapFloor_swigregister, METH_O, NULL},
	 { "YoYInflationCapFloor_swiginit", YoYInflationCapFloor_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCap", _wrap_new_YoYInflationCap, METH_VARARGS, "new_YoYInflationCap(Leg leg, DoubleVector capRates) -> YoYInflationCap"},
	 { "delete_YoYInflationCap", _wrap_delete_YoYInflationCap, METH_O, "delete_YoYInflationCap(YoYInflationCap self)"},
	 { "YoYInflationCap_swigregister", YoYInflationCap_swigregister, METH_O, NULL},
	 { "YoYInflationCap_swiginit", YoYInflationCap_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationFloor", _wrap_new_YoYInflationFloor, METH_VARARGS, "new_YoYInflationFloor(Leg leg, DoubleVector floorRates) -> YoYInflationFloor"},
	 { "delete_YoYInflationFloor", _wrap_delete_YoYInflationFloor, METH_O, "delete_YoYInflationFloor(YoYInflationFloor self)"},
	 { "YoYInflationFloor_swigregister", YoYInflationFloor_swigregister, METH_O, NULL},
	 { "YoYInflationFloor_swiginit", YoYInflationFloor_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCollar", _wrap_new_YoYInflationCollar, METH_VARARGS, "new_YoYInflationCollar(Leg leg, DoubleVector capRates, DoubleVector floorRates) -> YoYInflationCollar"},
	 { "delete_YoYInflationCollar", _wrap_delete_YoYInflationCollar, METH_O, "delete_YoYInflationCollar(YoYInflationCollar self)"},
	 { "YoYInflationCollar_swigregister", YoYInflationCollar_swigregister, METH_O, NULL},
	 { "YoYInflationCollar_swiginit", YoYInflationCollar_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroInflationCurve", _wrap_new_ZeroInflationCurve, METH_VARARGS, "ZeroInflationCurve(Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, DateVector dates, DoubleVector rates, Linear interpolator=Linear())"},
	 { "ZeroInflationCurve_dates", _wrap_ZeroInflationCurve_dates, METH_O, "ZeroInflationCurve_dates(ZeroInflationCurve self) -> DateVector"},
	 { "ZeroInflationCurve_times", _wrap_ZeroInflationCurve_times, METH_O, "ZeroInflationCurve_times(ZeroInflationCurve self) -> DoubleVector"},
	 { "ZeroInflationCurve_data", _wrap_ZeroInflationCurve_data, METH_O, "ZeroInflationCurve_data(ZeroInflationCurve self) -> DoubleVector"},
	 { "ZeroInflationCurve_rates", _wrap_ZeroInflationCurve_rates, METH_O, "ZeroInflationCurve_rates(ZeroInflationCurve self) -> DoubleVector"},
	 { "ZeroInflationCurve_nodes", _wrap_ZeroInflationCurve_nodes, METH_O, "ZeroInflationCurve_nodes(ZeroInflationCurve self) -> NodeVector"},
	 { "delete_ZeroInflationCurve", _wrap_delete_ZeroInflationCurve, METH_O, "delete_ZeroInflationCurve(ZeroInflationCurve self)"},
	 { "ZeroInflationCurve_swigregister", ZeroInflationCurve_swigregister, METH_O, NULL},
	 { "ZeroInflationCurve_swiginit", ZeroInflationCurve_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationCurve", (PyCFunction)(void(*)(void))_wrap_new_YoYInflationCurve, METH_VARARGS|METH_KEYWORDS, "new_YoYInflationCurve(Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag, Frequency frequency, bool indexIsInterpolated, DateVector dates, DoubleVector rates, Linear interpolator=Linear()) -> YoYInflationCurve"},
	 { "YoYInflationCurve_dates", _wrap_YoYInflationCurve_dates, METH_O, "YoYInflationCurve_dates(YoYInflationCurve self) -> DateVector"},
	 { "YoYInflationCurve_times", _wrap_YoYInflationCurve_times, METH_O, "YoYInflationCurve_times(YoYInflationCurve self) -> DoubleVector"},
	 { "YoYInflationCurve_data", _wrap_YoYInflationCurve_data, METH_O, "YoYInflationCurve_data(YoYInflationCurve self) -> DoubleVector"},
	 { "YoYInflationCurve_rates", _wrap_YoYInflationCurve_rates, METH_O, "YoYInflationCurve_rates(YoYInflationCurve self) -> DoubleVector"},
	 { "YoYInflationCurve_nodes", _wrap_YoYInflationCurve_nodes, METH_O, "YoYInflationCurve_nodes(YoYInflationCurve self) -> NodeVector"},
	 { "delete_YoYInflationCurve", _wrap_delete_YoYInflationCurve, METH_O, "delete_YoYInflationCurve(YoYInflationCurve self)"},
	 { "YoYInflationCurve_swigregister", YoYInflationCurve_swigregister, METH_O, NULL},
	 { "YoYInflationCurve_swiginit", YoYInflationCurve_swiginit, METH_VARARGS, NULL},
	 { "YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates", _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates, METH_O, "YoYCapFloorTermPriceSurface_atmYoYSwapTimeRates(YoYCapFloorTermPriceSurface self) -> PairDoubleVector"},
	 { "YoYCapFloorTermPriceSurface_atmYoYSwapDateRates", _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapDateRates, METH_O, "YoYCapFloorTermPriceSurface_atmYoYSwapDateRates(YoYCapFloorTermPriceSurface self) -> std::pair< std::vector< Date,std::allocator< Date > >,std::vector< Rate,std::allocator< Rate > > >"},
	 { "YoYCapFloorTermPriceSurface_YoYTS", _wrap_YoYCapFloorTermPriceSurface_YoYTS, METH_O, "YoYCapFloorTermPriceSurface_YoYTS(YoYCapFloorTermPriceSurface self) -> ext::shared_ptr< YoYInflationTermStructure >"},
	 { "YoYCapFloorTermPriceSurface_yoyIndex", _wrap_YoYCapFloorTermPriceSurface_yoyIndex, METH_O, "YoYCapFloorTermPriceSurface_yoyIndex(YoYCapFloorTermPriceSurface self) -> ext::shared_ptr< YoYInflationIndex >"},
	 { "YoYCapFloorTermPriceSurface_businessDayConvention", _wrap_YoYCapFloorTermPriceSurface_businessDayConvention, METH_O, "YoYCapFloorTermPriceSurface_businessDayConvention(YoYCapFloorTermPriceSurface self) -> BusinessDayConvention"},
	 { "YoYCapFloorTermPriceSurface_fixingDays", _wrap_YoYCapFloorTermPriceSurface_fixingDays, METH_O, "YoYCapFloorTermPriceSurface_fixingDays(YoYCapFloorTermPriceSurface self) -> Natural"},
	 { "YoYCapFloorTermPriceSurface_price", _wrap_YoYCapFloorTermPriceSurface_price, METH_VARARGS, "\n"
		"YoYCapFloorTermPriceSurface_price(YoYCapFloorTermPriceSurface self, Date d, Rate k) -> Real\n"
		"YoYCapFloorTermPriceSurface_price(YoYCapFloorTermPriceSurface self, Period d, Rate k) -> Real\n"
		""},
	 { "YoYCapFloorTermPriceSurface_capPrice", _wrap_YoYCapFloorTermPriceSurface_capPrice, METH_VARARGS, "\n"
		"YoYCapFloorTermPriceSurface_capPrice(YoYCapFloorTermPriceSurface self, Date d, Rate k) -> Real\n"
		"YoYCapFloorTermPriceSurface_capPrice(YoYCapFloorTermPriceSurface self, Period d, Rate k) -> Real\n"
		""},
	 { "YoYCapFloorTermPriceSurface_floorPrice", _wrap_YoYCapFloorTermPriceSurface_floorPrice, METH_VARARGS, "\n"
		"YoYCapFloorTermPriceSurface_floorPrice(YoYCapFloorTermPriceSurface self, Date d, Rate k) -> Real\n"
		"YoYCapFloorTermPriceSurface_floorPrice(YoYCapFloorTermPriceSurface self, Period d, Rate k) -> Real\n"
		""},
	 { "YoYCapFloorTermPriceSurface_atmYoYSwapRate", _wrap_YoYCapFloorTermPriceSurface_atmYoYSwapRate, METH_VARARGS, "\n"
		"YoYCapFloorTermPriceSurface_atmYoYSwapRate(YoYCapFloorTermPriceSurface self, Date d, bool extrapolate=True) -> Rate\n"
		"YoYCapFloorTermPriceSurface_atmYoYSwapRate(YoYCapFloorTermPriceSurface self, Period d, bool extrapolate=True) -> Rate\n"
		""},
	 { "YoYCapFloorTermPriceSurface_atmYoYRate", _wrap_YoYCapFloorTermPriceSurface_atmYoYRate, METH_VARARGS, "\n"
		"YoYCapFloorTermPriceSurface_atmYoYRate(YoYCapFloorTermPriceSurface self, Date d, Period obsLag=Period(-1,Days), bool extrapolate=True) -> Rate\n"
		"YoYCapFloorTermPriceSurface_atmYoYRate(YoYCapFloorTermPriceSurface self, Period d, Period obsLag=Period(-1,Days), bool extrapolate=True) -> Rate\n"
		""},
	 { "YoYCapFloorTermPriceSurface_strikes", _wrap_YoYCapFloorTermPriceSurface_strikes, METH_O, "YoYCapFloorTermPriceSurface_strikes(YoYCapFloorTermPriceSurface self) -> DoubleVector"},
	 { "YoYCapFloorTermPriceSurface_capStrikes", _wrap_YoYCapFloorTermPriceSurface_capStrikes, METH_O, "YoYCapFloorTermPriceSurface_capStrikes(YoYCapFloorTermPriceSurface self) -> DoubleVector"},
	 { "YoYCapFloorTermPriceSurface_floorStrikes", _wrap_YoYCapFloorTermPriceSurface_floorStrikes, METH_O, "YoYCapFloorTermPriceSurface_floorStrikes(YoYCapFloorTermPriceSurface self) -> DoubleVector"},
	 { "YoYCapFloorTermPriceSurface_maturities", _wrap_YoYCapFloorTermPriceSurface_maturities, METH_O, "YoYCapFloorTermPriceSurface_maturities(YoYCapFloorTermPriceSurface self) -> PeriodVector"},
	 { "YoYCapFloorTermPriceSurface_minStrike", _wrap_YoYCapFloorTermPriceSurface_minStrike, METH_O, "YoYCapFloorTermPriceSurface_minStrike(YoYCapFloorTermPriceSurface self) -> Rate"},
	 { "YoYCapFloorTermPriceSurface_maxStrike", _wrap_YoYCapFloorTermPriceSurface_maxStrike, METH_O, "YoYCapFloorTermPriceSurface_maxStrike(YoYCapFloorTermPriceSurface self) -> Rate"},
	 { "YoYCapFloorTermPriceSurface_minMaturity", _wrap_YoYCapFloorTermPriceSurface_minMaturity, METH_O, "YoYCapFloorTermPriceSurface_minMaturity(YoYCapFloorTermPriceSurface self) -> Date"},
	 { "YoYCapFloorTermPriceSurface_maxMaturity", _wrap_YoYCapFloorTermPriceSurface_maxMaturity, METH_O, "YoYCapFloorTermPriceSurface_maxMaturity(YoYCapFloorTermPriceSurface self) -> Date"},
	 { "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor", _wrap_YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor, METH_VARARGS, "YoYCapFloorTermPriceSurface_yoyOptionDateFromTenor(YoYCapFloorTermPriceSurface self, Period p) -> Date"},
	 { "delete_YoYCapFloorTermPriceSurface", _wrap_delete_YoYCapFloorTermPriceSurface, METH_O, "delete_YoYCapFloorTermPriceSurface(YoYCapFloorTermPriceSurface self)"},
	 { "YoYCapFloorTermPriceSurface_swigregister", YoYCapFloorTermPriceSurface_swigregister, METH_O, NULL},
	 { "new_YoYInflationCapFloorTermPriceSurface", _wrap_new_YoYInflationCapFloorTermPriceSurface, METH_VARARGS, "YoYInflationCapFloorTermPriceSurface(Natural fixingDays, Period yyLag, ext::shared_ptr< YoYInflationIndex > const & yii, Rate baseRate, YieldTermStructureHandle nominal, DayCounter dc, Calendar cal, BusinessDayConvention const & bdc, DoubleVector cStrikes, DoubleVector fStrikes, PeriodVector cfMaturities, Matrix cPrice, Matrix fPrice, Bicubic interpolator2d=Bicubic(), Cubic interpolator1d=Cubic())"},
	 { "delete_YoYInflationCapFloorTermPriceSurface", _wrap_delete_YoYInflationCapFloorTermPriceSurface, METH_O, "delete_YoYInflationCapFloorTermPriceSurface(YoYInflationCapFloorTermPriceSurface self)"},
	 { "YoYInflationCapFloorTermPriceSurface_swigregister", YoYInflationCapFloorTermPriceSurface_swigregister, METH_O, NULL},
	 { "YoYInflationCapFloorTermPriceSurface_swiginit", YoYInflationCapFloorTermPriceSurface_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationBlackCapFloorEngine", _wrap_new_YoYInflationBlackCapFloorEngine, METH_VARARGS, "new_YoYInflationBlackCapFloorEngine(ext::shared_ptr< YoYInflationIndex > const & arg1, YoYOptionletVolatilitySurfaceHandle vol, YieldTermStructureHandle nominalTermStructure) -> YoYInflationBlackCapFloorEngine"},
	 { "delete_YoYInflationBlackCapFloorEngine", _wrap_delete_YoYInflationBlackCapFloorEngine, METH_O, "delete_YoYInflationBlackCapFloorEngine(YoYInflationBlackCapFloorEngine self)"},
	 { "YoYInflationBlackCapFloorEngine_swigregister", YoYInflationBlackCapFloorEngine_swigregister, METH_O, NULL},
	 { "YoYInflationBlackCapFloorEngine_swiginit", YoYInflationBlackCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationUnitDisplacedBlackCapFloorEngine", _wrap_new_YoYInflationUnitDisplacedBlackCapFloorEngine, METH_VARARGS, "new_YoYInflationUnitDisplacedBlackCapFloorEngine(ext::shared_ptr< YoYInflationIndex > const & arg1, YoYOptionletVolatilitySurfaceHandle vol, YieldTermStructureHandle nominalTermStructure) -> YoYInflationUnitDisplacedBlackCapFloorEngine"},
	 { "delete_YoYInflationUnitDisplacedBlackCapFloorEngine", _wrap_delete_YoYInflationUnitDisplacedBlackCapFloorEngine, METH_O, "delete_YoYInflationUnitDisplacedBlackCapFloorEngine(YoYInflationUnitDisplacedBlackCapFloorEngine self)"},
	 { "YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister", YoYInflationUnitDisplacedBlackCapFloorEngine_swigregister, METH_O, NULL},
	 { "YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit", YoYInflationUnitDisplacedBlackCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_YoYInflationBachelierCapFloorEngine", _wrap_new_YoYInflationBachelierCapFloorEngine, METH_VARARGS, "new_YoYInflationBachelierCapFloorEngine(ext::shared_ptr< YoYInflationIndex > const & arg1, YoYOptionletVolatilitySurfaceHandle vol, YieldTermStructureHandle nominalTermStructure) -> YoYInflationBachelierCapFloorEngine"},
	 { "delete_YoYInflationBachelierCapFloorEngine", _wrap_delete_YoYInflationBachelierCapFloorEngine, METH_O, "delete_YoYInflationBachelierCapFloorEngine(YoYInflationBachelierCapFloorEngine self)"},
	 { "YoYInflationBachelierCapFloorEngine_swigregister", YoYInflationBachelierCapFloorEngine_swigregister, METH_O, NULL},
	 { "YoYInflationBachelierCapFloorEngine_swiginit", YoYInflationBachelierCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_YoYOptionletHelper", _wrap_new_YoYOptionletHelper, METH_VARARGS, "new_YoYOptionletHelper(QuoteHandle price, Real notional, YoYInflationCapFloor::Type capFloorType, Period lag, DayCounter yoyDayCounter, Calendar paymentCalendar, Natural fixingDays, ext::shared_ptr< YoYInflationIndex > const & index, Rate strike, Size n, ext::shared_ptr< PricingEngine > const & pricer) -> YoYOptionletHelper"},
	 { "delete_YoYOptionletHelper", _wrap_delete_YoYOptionletHelper, METH_O, "delete_YoYOptionletHelper(YoYOptionletHelper self)"},
	 { "YoYOptionletHelper_swigregister", YoYOptionletHelper_swigregister, METH_O, NULL},
	 { "YoYOptionletHelper_swiginit", YoYOptionletHelper_swiginit, METH_VARARGS, NULL},
	 { "YoYOptionletStripper_initialize", _wrap_YoYOptionletStripper_initialize, METH_VARARGS, "YoYOptionletStripper_initialize(YoYOptionletStripper self, ext::shared_ptr< YoYCapFloorTermPriceSurface > const & surf, ext::shared_ptr< PricingEngine > const & pricer, Real slope)"},
	 { "YoYOptionletStripper_maxStrike", _wrap_YoYOptionletStripper_maxStrike, METH_O, "YoYOptionletStripper_maxStrike(YoYOptionletStripper self) -> Rate"},
	 { "YoYOptionletStripper_strikes", _wrap_YoYOptionletStripper_strikes, METH_O, "YoYOptionletStripper_strikes(YoYOptionletStripper self) -> DoubleVector"},
	 { "YoYOptionletStripper_slice", _wrap_YoYOptionletStripper_slice, METH_VARARGS, "YoYOptionletStripper_slice(YoYOptionletStripper self, Date d) -> PairDoubleVector"},
	 { "delete_YoYOptionletStripper", _wrap_delete_YoYOptionletStripper, METH_O, "delete_YoYOptionletStripper(YoYOptionletStripper self)"},
	 { "YoYOptionletStripper_swigregister", YoYOptionletStripper_swigregister, METH_O, NULL},
	 { "new_InterpolatedYoYInflationOptionletStripper", _wrap_new_InterpolatedYoYInflationOptionletStripper, METH_NOARGS, "new_InterpolatedYoYInflationOptionletStripper() -> InterpolatedYoYInflationOptionletStripper"},
	 { "delete_InterpolatedYoYInflationOptionletStripper", _wrap_delete_InterpolatedYoYInflationOptionletStripper, METH_O, "delete_InterpolatedYoYInflationOptionletStripper(InterpolatedYoYInflationOptionletStripper self)"},
	 { "InterpolatedYoYInflationOptionletStripper_swigregister", InterpolatedYoYInflationOptionletStripper_swigregister, METH_O, NULL},
	 { "InterpolatedYoYInflationOptionletStripper_swiginit", InterpolatedYoYInflationOptionletStripper_swiginit, METH_VARARGS, NULL},
	 { "new_InterpolatedYoYInflationOptionletVolatilityCurve", _wrap_new_InterpolatedYoYInflationOptionletVolatilityCurve, METH_VARARGS, "InterpolatedYoYInflationOptionletVolatilityCurve(Natural settlementDays, Calendar arg2, BusinessDayConvention bdc, DayCounter dc, Period lag, Frequency frequency, bool indexIsInterpolated, DateVector d, DoubleVector v, Rate minStrike, Rate maxStrike, Linear i=Linear())"},
	 { "delete_InterpolatedYoYInflationOptionletVolatilityCurve", _wrap_delete_InterpolatedYoYInflationOptionletVolatilityCurve, METH_O, "delete_InterpolatedYoYInflationOptionletVolatilityCurve(InterpolatedYoYInflationOptionletVolatilityCurve self)"},
	 { "InterpolatedYoYInflationOptionletVolatilityCurve_swigregister", InterpolatedYoYInflationOptionletVolatilityCurve_swigregister, METH_O, NULL},
	 { "InterpolatedYoYInflationOptionletVolatilityCurve_swiginit", InterpolatedYoYInflationOptionletVolatilityCurve_swiginit, METH_VARARGS, NULL},
	 { "new_KInterpolatedYoYInflationOptionletVolatilitySurface", _wrap_new_KInterpolatedYoYInflationOptionletVolatilitySurface, METH_VARARGS, "KInterpolatedYoYInflationOptionletVolatilitySurface(Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, DayCounter dc, Period lag, ext::shared_ptr< YoYCapFloorTermPriceSurface > const & capFloorPrices, ext::shared_ptr< PricingEngine > const & pricer, ext::shared_ptr< YoYOptionletStripper > const & yoyOptionletStripper, Real slope, Linear interpolator=Linear())"},
	 { "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice", _wrap_KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice, METH_VARARGS, "KInterpolatedYoYInflationOptionletVolatilitySurface_Dslice(KInterpolatedYoYInflationOptionletVolatilitySurface self, Date d) -> PairDoubleVector"},
	 { "delete_KInterpolatedYoYInflationOptionletVolatilitySurface", _wrap_delete_KInterpolatedYoYInflationOptionletVolatilitySurface, METH_O, "delete_KInterpolatedYoYInflationOptionletVolatilitySurface(KInterpolatedYoYInflationOptionletVolatilitySurface self)"},
	 { "KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister", KInterpolatedYoYInflationOptionletVolatilitySurface_swigregister, METH_O, NULL},
	 { "KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit", KInterpolatedYoYInflationOptionletVolatilitySurface_swiginit, METH_VARARGS, NULL},
	 { "delete_ShortRateModel", _wrap_delete_ShortRateModel, METH_O, "delete_ShortRateModel(ShortRateModel self)"},
	 { "ShortRateModel_swigregister", ShortRateModel_swigregister, METH_O, NULL},
	 { "new_ShortRateModelHandle", _wrap_new_ShortRateModelHandle, METH_VARARGS, "ShortRateModelHandle(ext::shared_ptr< ShortRateModel > const & arg1=ext::shared_ptr())"},
	 { "ShortRateModelHandle___deref__", _wrap_ShortRateModelHandle___deref__, METH_O, "ShortRateModelHandle___deref__(ShortRateModelHandle self) -> ext::shared_ptr< ShortRateModel >"},
	 { "ShortRateModelHandle_currentLink", _wrap_ShortRateModelHandle_currentLink, METH_O, "ShortRateModelHandle_currentLink(ShortRateModelHandle self) -> ext::shared_ptr< ShortRateModel >"},
	 { "ShortRateModelHandle___nonzero__", _wrap_ShortRateModelHandle___nonzero__, METH_O, "ShortRateModelHandle___nonzero__(ShortRateModelHandle self) -> bool"},
	 { "ShortRateModelHandle___bool__", _wrap_ShortRateModelHandle___bool__, METH_O, "ShortRateModelHandle___bool__(ShortRateModelHandle self) -> bool"},
	 { "ShortRateModelHandle_asObservable", _wrap_ShortRateModelHandle_asObservable, METH_O, "ShortRateModelHandle_asObservable(ShortRateModelHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_ShortRateModelHandle", _wrap_delete_ShortRateModelHandle, METH_O, "delete_ShortRateModelHandle(ShortRateModelHandle self)"},
	 { "ShortRateModelHandle_params", _wrap_ShortRateModelHandle_params, METH_O, "ShortRateModelHandle_params(ShortRateModelHandle self) -> Array"},
	 { "ShortRateModelHandle_calibrate", _wrap_ShortRateModelHandle_calibrate, METH_VARARGS, "ShortRateModelHandle_calibrate(ShortRateModelHandle self, CalibrationHelperVector arg2, OptimizationMethod arg3, EndCriteria arg4, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"},
	 { "ShortRateModelHandle_setParams", _wrap_ShortRateModelHandle_setParams, METH_VARARGS, "ShortRateModelHandle_setParams(ShortRateModelHandle self, Array params)"},
	 { "ShortRateModelHandle_value", _wrap_ShortRateModelHandle_value, METH_VARARGS, "ShortRateModelHandle_value(ShortRateModelHandle self, Array params, CalibrationHelperVector arg3) -> Real"},
	 { "ShortRateModelHandle_constraint", _wrap_ShortRateModelHandle_constraint, METH_O, "ShortRateModelHandle_constraint(ShortRateModelHandle self) -> ext::shared_ptr< Constraint > const &"},
	 { "ShortRateModelHandle_endCriteria", _wrap_ShortRateModelHandle_endCriteria, METH_O, "ShortRateModelHandle_endCriteria(ShortRateModelHandle self) -> EndCriteria::Type"},
	 { "ShortRateModelHandle_problemValues", _wrap_ShortRateModelHandle_problemValues, METH_O, "ShortRateModelHandle_problemValues(ShortRateModelHandle self) -> Array"},
	 { "ShortRateModelHandle_functionEvaluation", _wrap_ShortRateModelHandle_functionEvaluation, METH_O, "ShortRateModelHandle_functionEvaluation(ShortRateModelHandle self) -> Integer"},
	 { "ShortRateModelHandle_swigregister", ShortRateModelHandle_swigregister, METH_O, NULL},
	 { "ShortRateModelHandle_swiginit", ShortRateModelHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableShortRateModelHandle", _wrap_new_RelinkableShortRateModelHandle, METH_VARARGS, "RelinkableShortRateModelHandle(ext::shared_ptr< ShortRateModel > const & arg1=ext::shared_ptr())"},
	 { "RelinkableShortRateModelHandle_linkTo", _wrap_RelinkableShortRateModelHandle_linkTo, METH_VARARGS, "RelinkableShortRateModelHandle_linkTo(RelinkableShortRateModelHandle self, ext::shared_ptr< ShortRateModel > const & arg2)"},
	 { "RelinkableShortRateModelHandle_reset", _wrap_RelinkableShortRateModelHandle_reset, METH_O, "RelinkableShortRateModelHandle_reset(RelinkableShortRateModelHandle self)"},
	 { "delete_RelinkableShortRateModelHandle", _wrap_delete_RelinkableShortRateModelHandle, METH_O, "delete_RelinkableShortRateModelHandle(RelinkableShortRateModelHandle self)"},
	 { "RelinkableShortRateModelHandle_swigregister", RelinkableShortRateModelHandle_swigregister, METH_O, NULL},
	 { "RelinkableShortRateModelHandle_swiginit", RelinkableShortRateModelHandle_swiginit, METH_VARARGS, NULL},
	 { "OneFactorAffineModel_discountBond", _wrap_OneFactorAffineModel_discountBond, METH_VARARGS, "\n"
		"OneFactorAffineModel_discountBond(OneFactorAffineModel self, Time now, Time maturity, Array factors) -> Real\n"
		"OneFactorAffineModel_discountBond(OneFactorAffineModel self, Time now, Time maturity, Rate rate) -> Real\n"
		""},
	 { "OneFactorAffineModel_discount", _wrap_OneFactorAffineModel_discount, METH_VARARGS, "OneFactorAffineModel_discount(OneFactorAffineModel self, Time t) -> DiscountFactor"},
	 { "delete_OneFactorAffineModel", _wrap_delete_OneFactorAffineModel, METH_O, "delete_OneFactorAffineModel(OneFactorAffineModel self)"},
	 { "OneFactorAffineModel_swigregister", OneFactorAffineModel_swigregister, METH_O, NULL},
	 { "new_Vasicek", _wrap_new_Vasicek, METH_VARARGS, "Vasicek(Rate r0=0.05, Real a=0.1, Real b=0.05, Real sigma=0.01, Real lambda_parameter=0.0)"},
	 { "delete_Vasicek", _wrap_delete_Vasicek, METH_O, "delete_Vasicek(Vasicek self)"},
	 { "Vasicek_swigregister", Vasicek_swigregister, METH_O, NULL},
	 { "Vasicek_swiginit", Vasicek_swiginit, METH_VARARGS, NULL},
	 { "new_HullWhite", _wrap_new_HullWhite, METH_VARARGS, "HullWhite(YieldTermStructureHandle termStructure, Real a=0.1, Real sigma=0.01)"},
	 { "HullWhite_convexityBias", _wrap_HullWhite_convexityBias, METH_VARARGS, "HullWhite_convexityBias(Real futurePrice, Time t, Time T, Real sigma, Real a) -> Rate"},
	 { "HullWhite_termStructure", _wrap_HullWhite_termStructure, METH_O, "HullWhite_termStructure(HullWhite self) -> YieldTermStructureHandle"},
	 { "delete_HullWhite", _wrap_delete_HullWhite, METH_O, "delete_HullWhite(HullWhite self)"},
	 { "HullWhite_swigregister", HullWhite_swigregister, METH_O, NULL},
	 { "HullWhite_swiginit", HullWhite_swiginit, METH_VARARGS, NULL},
	 { "new_BlackKarasinski", _wrap_new_BlackKarasinski, METH_VARARGS, "BlackKarasinski(YieldTermStructureHandle termStructure, Real a=0.1, Real sigma=0.1)"},
	 { "BlackKarasinski_termStructure", _wrap_BlackKarasinski_termStructure, METH_O, "BlackKarasinski_termStructure(BlackKarasinski self) -> YieldTermStructureHandle"},
	 { "delete_BlackKarasinski", _wrap_delete_BlackKarasinski, METH_O, "delete_BlackKarasinski(BlackKarasinski self)"},
	 { "BlackKarasinski_swigregister", BlackKarasinski_swigregister, METH_O, NULL},
	 { "BlackKarasinski_swiginit", BlackKarasinski_swiginit, METH_VARARGS, NULL},
	 { "new_CoxIngersollRoss", _wrap_new_CoxIngersollRoss, METH_VARARGS, "CoxIngersollRoss(Rate r0=0.01, Real theta=0.1, Real k=0.1, Real sigma=0.1)"},
	 { "CoxIngersollRoss_discount", _wrap_CoxIngersollRoss_discount, METH_VARARGS, "CoxIngersollRoss_discount(CoxIngersollRoss self, Time t) -> DiscountFactor"},
	 { "delete_CoxIngersollRoss", _wrap_delete_CoxIngersollRoss, METH_O, "delete_CoxIngersollRoss(CoxIngersollRoss self)"},
	 { "CoxIngersollRoss_swigregister", CoxIngersollRoss_swigregister, METH_O, NULL},
	 { "CoxIngersollRoss_swiginit", CoxIngersollRoss_swiginit, METH_VARARGS, NULL},
	 { "new_ExtendedCoxIngersollRoss", _wrap_new_ExtendedCoxIngersollRoss, METH_VARARGS, "ExtendedCoxIngersollRoss(YieldTermStructureHandle termStructure, Real theta=0.1, Real k=0.1, Real sigma=0.1, Real x0=0.05)"},
	 { "ExtendedCoxIngersollRoss_discount", _wrap_ExtendedCoxIngersollRoss_discount, METH_VARARGS, "ExtendedCoxIngersollRoss_discount(ExtendedCoxIngersollRoss self, Time t) -> DiscountFactor"},
	 { "delete_ExtendedCoxIngersollRoss", _wrap_delete_ExtendedCoxIngersollRoss, METH_O, "delete_ExtendedCoxIngersollRoss(ExtendedCoxIngersollRoss self)"},
	 { "ExtendedCoxIngersollRoss_swigregister", ExtendedCoxIngersollRoss_swigregister, METH_O, NULL},
	 { "ExtendedCoxIngersollRoss_swiginit", ExtendedCoxIngersollRoss_swiginit, METH_VARARGS, NULL},
	 { "new_G2", _wrap_new_G2, METH_VARARGS, "G2(YieldTermStructureHandle termStructure, Real a=0.1, Real sigma=0.01, Real b=0.1, Real eta=0.01, Real rho=-0.75)"},
	 { "G2_termStructure", _wrap_G2_termStructure, METH_O, "G2_termStructure(G2 self) -> YieldTermStructureHandle"},
	 { "delete_G2", _wrap_delete_G2, METH_O, "delete_G2(G2 self)"},
	 { "G2_swigregister", G2_swigregister, METH_O, NULL},
	 { "G2_swiginit", G2_swiginit, METH_VARARGS, NULL},
	 { "new_JamshidianSwaptionEngine", _wrap_new_JamshidianSwaptionEngine, METH_VARARGS, "JamshidianSwaptionEngine(ext::shared_ptr< OneFactorAffineModel > const & model, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())"},
	 { "delete_JamshidianSwaptionEngine", _wrap_delete_JamshidianSwaptionEngine, METH_O, "delete_JamshidianSwaptionEngine(JamshidianSwaptionEngine self)"},
	 { "JamshidianSwaptionEngine_swigregister", JamshidianSwaptionEngine_swigregister, METH_O, NULL},
	 { "JamshidianSwaptionEngine_swiginit", JamshidianSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_TreeSwaptionEngine", _wrap_new_TreeSwaptionEngine, METH_VARARGS, "\n"
		"TreeSwaptionEngine(ext::shared_ptr< ShortRateModel > const & model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		"TreeSwaptionEngine(ext::shared_ptr< ShortRateModel > const & model, TimeGrid grid, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		"TreeSwaptionEngine(ShortRateModelHandle model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		""},
	 { "delete_TreeSwaptionEngine", _wrap_delete_TreeSwaptionEngine, METH_O, "delete_TreeSwaptionEngine(TreeSwaptionEngine self)"},
	 { "TreeSwaptionEngine_swigregister", TreeSwaptionEngine_swigregister, METH_O, NULL},
	 { "TreeSwaptionEngine_swiginit", TreeSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticCapFloorEngine", _wrap_new_AnalyticCapFloorEngine, METH_VARARGS, "AnalyticCapFloorEngine(ext::shared_ptr< OneFactorAffineModel > const & model, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())"},
	 { "delete_AnalyticCapFloorEngine", _wrap_delete_AnalyticCapFloorEngine, METH_O, "delete_AnalyticCapFloorEngine(AnalyticCapFloorEngine self)"},
	 { "AnalyticCapFloorEngine_swigregister", AnalyticCapFloorEngine_swigregister, METH_O, NULL},
	 { "AnalyticCapFloorEngine_swiginit", AnalyticCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_TreeCapFloorEngine", _wrap_new_TreeCapFloorEngine, METH_VARARGS, "\n"
		"TreeCapFloorEngine(ext::shared_ptr< ShortRateModel > const & model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		"TreeCapFloorEngine(ext::shared_ptr< ShortRateModel > const & model, TimeGrid grid, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		""},
	 { "delete_TreeCapFloorEngine", _wrap_delete_TreeCapFloorEngine, METH_O, "delete_TreeCapFloorEngine(TreeCapFloorEngine self)"},
	 { "TreeCapFloorEngine_swigregister", TreeCapFloorEngine_swigregister, METH_O, NULL},
	 { "TreeCapFloorEngine_swiginit", TreeCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_G2SwaptionEngine", _wrap_new_G2SwaptionEngine, METH_VARARGS, "new_G2SwaptionEngine(ext::shared_ptr< G2 > const & model, Real range, Size intervals) -> G2SwaptionEngine"},
	 { "delete_G2SwaptionEngine", _wrap_delete_G2SwaptionEngine, METH_O, "delete_G2SwaptionEngine(G2SwaptionEngine self)"},
	 { "G2SwaptionEngine_swigregister", G2SwaptionEngine_swigregister, METH_O, NULL},
	 { "G2SwaptionEngine_swiginit", G2SwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdG2SwaptionEngine", _wrap_new_FdG2SwaptionEngine, METH_VARARGS, "FdG2SwaptionEngine(ext::shared_ptr< G2 > const & model, Size tGrid=100, Size xGrid=50, Size yGrid=50, Size dampingSteps=0, Real invEps=1e-5, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())"},
	 { "delete_FdG2SwaptionEngine", _wrap_delete_FdG2SwaptionEngine, METH_O, "delete_FdG2SwaptionEngine(FdG2SwaptionEngine self)"},
	 { "FdG2SwaptionEngine_swigregister", FdG2SwaptionEngine_swigregister, METH_O, NULL},
	 { "FdG2SwaptionEngine_swiginit", FdG2SwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdHullWhiteSwaptionEngine", _wrap_new_FdHullWhiteSwaptionEngine, METH_VARARGS, "FdHullWhiteSwaptionEngine(ext::shared_ptr< HullWhite > const & model, Size tGrid=100, Size xGrid=100, Size dampingSteps=0, Real invEps=1e-5, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())"},
	 { "delete_FdHullWhiteSwaptionEngine", _wrap_delete_FdHullWhiteSwaptionEngine, METH_O, "delete_FdHullWhiteSwaptionEngine(FdHullWhiteSwaptionEngine self)"},
	 { "FdHullWhiteSwaptionEngine_swigregister", FdHullWhiteSwaptionEngine_swigregister, METH_O, NULL},
	 { "FdHullWhiteSwaptionEngine_swiginit", FdHullWhiteSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticBSMHullWhiteEngine", _wrap_new_AnalyticBSMHullWhiteEngine, METH_VARARGS, "new_AnalyticBSMHullWhiteEngine(Real equityShortRateCorrelation, ext::shared_ptr< GeneralizedBlackScholesProcess > const & arg2, ext::shared_ptr< HullWhite > const & arg3) -> AnalyticBSMHullWhiteEngine"},
	 { "delete_AnalyticBSMHullWhiteEngine", _wrap_delete_AnalyticBSMHullWhiteEngine, METH_O, "delete_AnalyticBSMHullWhiteEngine(AnalyticBSMHullWhiteEngine self)"},
	 { "AnalyticBSMHullWhiteEngine_swigregister", AnalyticBSMHullWhiteEngine_swigregister, METH_O, NULL},
	 { "AnalyticBSMHullWhiteEngine_swiginit", AnalyticBSMHullWhiteEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BondPrice", _wrap_new_BondPrice, METH_VARARGS, "new_BondPrice(Real amount, BondPrice::Type type) -> BondPrice"},
	 { "BondPrice_amount", _wrap_BondPrice_amount, METH_O, "BondPrice_amount(BondPrice self) -> Real"},
	 { "BondPrice_type", _wrap_BondPrice_type, METH_O, "BondPrice_type(BondPrice self) -> BondPrice::Type"},
	 { "delete_BondPrice", _wrap_delete_BondPrice, METH_O, "delete_BondPrice(BondPrice self)"},
	 { "BondPrice_swigregister", BondPrice_swigregister, METH_O, NULL},
	 { "BondPrice_swiginit", BondPrice_swiginit, METH_VARARGS, NULL},
	 { "new_Bond", _wrap_new_Bond, METH_VARARGS, "\n"
		"Bond(Natural settlementDays, Calendar calendar, Real faceAmount, Date maturityDate, Date issueDate=Date(), Leg cashflows=Leg())\n"
		"Bond(Natural settlementDays, Calendar calendar, Date issueDate=Date(), Leg coupons=Leg())\n"
		""},
	 { "Bond_nextCouponRate", _wrap_Bond_nextCouponRate, METH_VARARGS, "Bond_nextCouponRate(Bond self, Date d=Date()) -> Rate"},
	 { "Bond_previousCouponRate", _wrap_Bond_previousCouponRate, METH_VARARGS, "Bond_previousCouponRate(Bond self, Date d=Date()) -> Rate"},
	 { "Bond_settlementDays", _wrap_Bond_settlementDays, METH_O, "Bond_settlementDays(Bond self) -> Natural"},
	 { "Bond_settlementDate", _wrap_Bond_settlementDate, METH_VARARGS, "Bond_settlementDate(Bond self, Date d=Date()) -> Date"},
	 { "Bond_startDate", _wrap_Bond_startDate, METH_O, "Bond_startDate(Bond self) -> Date"},
	 { "Bond_maturityDate", _wrap_Bond_maturityDate, METH_O, "Bond_maturityDate(Bond self) -> Date"},
	 { "Bond_issueDate", _wrap_Bond_issueDate, METH_O, "Bond_issueDate(Bond self) -> Date"},
	 { "Bond_cashflows", _wrap_Bond_cashflows, METH_O, "Bond_cashflows(Bond self) -> Leg"},
	 { "Bond_redemptions", _wrap_Bond_redemptions, METH_O, "Bond_redemptions(Bond self) -> Leg"},
	 { "Bond_redemption", _wrap_Bond_redemption, METH_O, "Bond_redemption(Bond self) -> ext::shared_ptr< CashFlow >"},
	 { "Bond_calendar", _wrap_Bond_calendar, METH_O, "Bond_calendar(Bond self) -> Calendar"},
	 { "Bond_notionals", _wrap_Bond_notionals, METH_O, "Bond_notionals(Bond self) -> DoubleVector"},
	 { "Bond_notional", _wrap_Bond_notional, METH_VARARGS, "Bond_notional(Bond self, Date d=Date()) -> Real"},
	 { "Bond_cleanPrice", _wrap_Bond_cleanPrice, METH_VARARGS, "\n"
		"Bond_cleanPrice(Bond self) -> Real\n"
		"Bond_cleanPrice(Bond self, Rate _yield, DayCounter dc, Compounding compounding, Frequency frequency, Date settlement=Date()) -> Real\n"
		""},
	 { "Bond_dirtyPrice", _wrap_Bond_dirtyPrice, METH_VARARGS, "\n"
		"Bond_dirtyPrice(Bond self) -> Real\n"
		"Bond_dirtyPrice(Bond self, Rate _yield, DayCounter dc, Compounding compounding, Frequency frequency, Date settlement=Date()) -> Real\n"
		""},
	 { "Bond_bondYield", _wrap_Bond_bondYield, METH_VARARGS, "\n"
		"Bond_bondYield(Bond self, DayCounter dc, Compounding compounding, Frequency freq, Real accuracy=1.0e-8, Size maxEvaluations=100) -> Real\n"
		"Bond_bondYield(Bond self, Real cleanPrice, DayCounter dc, Compounding compounding, Frequency freq, Date settlement=Date(), Real accuracy=1.0e-8, Size maxEvaluations=100) -> Real\n"
		""},
	 { "Bond_accruedAmount", _wrap_Bond_accruedAmount, METH_VARARGS, "Bond_accruedAmount(Bond self, Date settlement=Date()) -> Real"},
	 { "Bond_settlementValue", _wrap_Bond_settlementValue, METH_VARARGS, "\n"
		"Bond_settlementValue(Bond self) -> Real\n"
		"Bond_settlementValue(Bond self, Real cleanPrice) -> Real\n"
		""},
	 { "delete_Bond", _wrap_delete_Bond, METH_O, "delete_Bond(Bond self)"},
	 { "Bond_swigregister", Bond_swigregister, METH_O, NULL},
	 { "Bond_swiginit", Bond_swiginit, METH_VARARGS, NULL},
	 { "simplifyNotificationGraph", _wrap_simplifyNotificationGraph, METH_VARARGS, "\n"
		"simplifyNotificationGraph(Swap swap, bool unregisterCoupons=False)\n"
		"simplifyNotificationGraph(Bond bond, bool unregisterCoupons=False)\n"
		""},
	 { "cleanPriceFromZSpread", _wrap_cleanPriceFromZSpread, METH_VARARGS, "cleanPriceFromZSpread(Bond bond, ext::shared_ptr< YieldTermStructure > const & discountCurve, Spread zSpread, DayCounter dc, Compounding compounding, Frequency freq, Date settlementDate=Date()) -> Real"},
	 { "sinkingSchedule", _wrap_sinkingSchedule, METH_VARARGS, "sinkingSchedule(Date startDate, Period bondLength, Frequency const & frequency, Calendar paymentCalendar) -> Schedule"},
	 { "sinkingNotionals", _wrap_sinkingNotionals, METH_VARARGS, "sinkingNotionals(Period bondLength, Frequency const & frequency, Rate couponRate, Real initialNotional) -> DoubleVector"},
	 { "new_ZeroCouponBond", (PyCFunction)(void(*)(void))_wrap_new_ZeroCouponBond, METH_VARARGS|METH_KEYWORDS, "new_ZeroCouponBond(Natural settlementDays, Calendar calendar, Real faceAmount, Date maturityDate, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date()) -> ZeroCouponBond"},
	 { "delete_ZeroCouponBond", _wrap_delete_ZeroCouponBond, METH_O, "delete_ZeroCouponBond(ZeroCouponBond self)"},
	 { "ZeroCouponBond_swigregister", ZeroCouponBond_swigregister, METH_O, NULL},
	 { "ZeroCouponBond_swiginit", ZeroCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_FixedRateBond", (PyCFunction)(void(*)(void))_wrap_new_FixedRateBond, METH_VARARGS|METH_KEYWORDS, "new_FixedRateBond(Integer settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=QuantLib::Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> FixedRateBond"},
	 { "FixedRateBond_frequency", _wrap_FixedRateBond_frequency, METH_O, "FixedRateBond_frequency(FixedRateBond self) -> Frequency"},
	 { "FixedRateBond_dayCounter", _wrap_FixedRateBond_dayCounter, METH_O, "FixedRateBond_dayCounter(FixedRateBond self) -> DayCounter"},
	 { "delete_FixedRateBond", _wrap_delete_FixedRateBond, METH_O, "delete_FixedRateBond(FixedRateBond self)"},
	 { "FixedRateBond_swigregister", FixedRateBond_swigregister, METH_O, NULL},
	 { "FixedRateBond_swiginit", FixedRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_AmortizingFixedRateBond", (PyCFunction)(void(*)(void))_wrap_new_AmortizingFixedRateBond, METH_VARARGS|METH_KEYWORDS, "new_AmortizingFixedRateBond(Integer settlementDays, DoubleVector notionals, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=QuantLib::Following, Date issueDate=Date(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, DoubleVector redemptions={ 100.0 }, Integer paymentLag=0) -> AmortizingFixedRateBond"},
	 { "AmortizingFixedRateBond_frequency", _wrap_AmortizingFixedRateBond_frequency, METH_O, "AmortizingFixedRateBond_frequency(AmortizingFixedRateBond self) -> Frequency"},
	 { "AmortizingFixedRateBond_dayCounter", _wrap_AmortizingFixedRateBond_dayCounter, METH_O, "AmortizingFixedRateBond_dayCounter(AmortizingFixedRateBond self) -> DayCounter"},
	 { "delete_AmortizingFixedRateBond", _wrap_delete_AmortizingFixedRateBond, METH_O, "delete_AmortizingFixedRateBond(AmortizingFixedRateBond self)"},
	 { "AmortizingFixedRateBond_swigregister", AmortizingFixedRateBond_swigregister, METH_O, NULL},
	 { "AmortizingFixedRateBond_swiginit", AmortizingFixedRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_AmortizingFloatingRateBond", (PyCFunction)(void(*)(void))_wrap_new_AmortizingFloatingRateBond, METH_VARARGS|METH_KEYWORDS, "new_AmortizingFloatingRateBond(Size settlementDays, DoubleVector notional, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=Following, Size fixingDays=Null< Size >(), DoubleVector gearings=std::vector< Real >(1, 1.0), DoubleVector spreads=std::vector< Spread >(1, 0.0), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool inArrears=False, Date issueDate=Date(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, DoubleVector redemptions={ 100.0 }, Integer paymentLag=0) -> AmortizingFloatingRateBond"},
	 { "delete_AmortizingFloatingRateBond", _wrap_delete_AmortizingFloatingRateBond, METH_O, "delete_AmortizingFloatingRateBond(AmortizingFloatingRateBond self)"},
	 { "AmortizingFloatingRateBond_swigregister", AmortizingFloatingRateBond_swigregister, METH_O, NULL},
	 { "AmortizingFloatingRateBond_swiginit", AmortizingFloatingRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_FloatingRateBond", (PyCFunction)(void(*)(void))_wrap_new_FloatingRateBond, METH_VARARGS|METH_KEYWORDS, "new_FloatingRateBond(Size settlementDays, Real faceAmount, Schedule schedule, ext::shared_ptr< IborIndex > const & index, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=Following, Size fixingDays=Null< Size >(), DoubleVector gearings=std::vector< Real >(), DoubleVector spreads=std::vector< Spread >(), DoubleVector caps=std::vector< Rate >(), DoubleVector floors=std::vector< Rate >(), bool inArrears=False, Real redemption=100.0, Date issueDate=Date(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> FloatingRateBond"},
	 { "delete_FloatingRateBond", _wrap_delete_FloatingRateBond, METH_O, "delete_FloatingRateBond(FloatingRateBond self)"},
	 { "FloatingRateBond_swigregister", FloatingRateBond_swigregister, METH_O, NULL},
	 { "FloatingRateBond_swiginit", FloatingRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_CmsRateBond", (PyCFunction)(void(*)(void))_wrap_new_CmsRateBond, METH_VARARGS|METH_KEYWORDS, "new_CmsRateBond(Size settlementDays, Real faceAmount, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention, Natural fixingDays, DoubleVector gearings, DoubleVector spreads, DoubleVector caps, DoubleVector floors, bool inArrears=False, Real redemption=100.0, Date issueDate=Date()) -> CmsRateBond"},
	 { "delete_CmsRateBond", _wrap_delete_CmsRateBond, METH_O, "delete_CmsRateBond(CmsRateBond self)"},
	 { "CmsRateBond_swigregister", CmsRateBond_swigregister, METH_O, NULL},
	 { "CmsRateBond_swiginit", CmsRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_AmortizingCmsRateBond", (PyCFunction)(void(*)(void))_wrap_new_AmortizingCmsRateBond, METH_VARARGS|METH_KEYWORDS, "new_AmortizingCmsRateBond(Natural settlementDays, DoubleVector notionals, Schedule schedule, ext::shared_ptr< SwapIndex > const & index, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=Following, Natural fixingDays=Null< Natural >(), DoubleVector gearings={ 1.0 }, DoubleVector spreads={ 0.0 }, DoubleVector caps={}, DoubleVector floors={}, bool inArrears=False, Date issueDate=Date()) -> AmortizingCmsRateBond"},
	 { "delete_AmortizingCmsRateBond", _wrap_delete_AmortizingCmsRateBond, METH_O, "delete_AmortizingCmsRateBond(AmortizingCmsRateBond self)"},
	 { "AmortizingCmsRateBond_swigregister", AmortizingCmsRateBond_swigregister, METH_O, NULL},
	 { "AmortizingCmsRateBond_swiginit", AmortizingCmsRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_DiscountingBondEngine", _wrap_new_DiscountingBondEngine, METH_O, "new_DiscountingBondEngine(YieldTermStructureHandle discountCurve) -> DiscountingBondEngine"},
	 { "delete_DiscountingBondEngine", _wrap_delete_DiscountingBondEngine, METH_O, "delete_DiscountingBondEngine(DiscountingBondEngine self)"},
	 { "DiscountingBondEngine_swigregister", DiscountingBondEngine_swigregister, METH_O, NULL},
	 { "DiscountingBondEngine_swiginit", DiscountingBondEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Callability", _wrap_new_Callability, METH_VARARGS, "new_Callability(BondPrice price, Callability::Type type, Date date) -> Callability"},
	 { "Callability_price", _wrap_Callability_price, METH_O, "Callability_price(Callability self) -> BondPrice"},
	 { "Callability_type", _wrap_Callability_type, METH_O, "Callability_type(Callability self) -> Callability::Type"},
	 { "Callability_date", _wrap_Callability_date, METH_O, "Callability_date(Callability self) -> Date"},
	 { "delete_Callability", _wrap_delete_Callability, METH_O, "delete_Callability(Callability self)"},
	 { "Callability_swigregister", Callability_swigregister, METH_O, NULL},
	 { "Callability_swiginit", Callability_swiginit, METH_VARARGS, NULL},
	 { "new_SoftCallability", _wrap_new_SoftCallability, METH_VARARGS, "new_SoftCallability(BondPrice price, Date date, Real trigger) -> SoftCallability"},
	 { "delete_SoftCallability", _wrap_delete_SoftCallability, METH_O, "delete_SoftCallability(SoftCallability self)"},
	 { "SoftCallability_swigregister", SoftCallability_swigregister, METH_O, NULL},
	 { "SoftCallability_swiginit", SoftCallability_swiginit, METH_VARARGS, NULL},
	 { "CallabilitySchedule_iterator", _wrap_CallabilitySchedule_iterator, METH_O, "CallabilitySchedule_iterator(CallabilitySchedule self) -> SwigPyIterator"},
	 { "CallabilitySchedule___nonzero__", _wrap_CallabilitySchedule___nonzero__, METH_O, "CallabilitySchedule___nonzero__(CallabilitySchedule self) -> bool"},
	 { "CallabilitySchedule___bool__", _wrap_CallabilitySchedule___bool__, METH_O, "CallabilitySchedule___bool__(CallabilitySchedule self) -> bool"},
	 { "CallabilitySchedule___len__", _wrap_CallabilitySchedule___len__, METH_O, "CallabilitySchedule___len__(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::size_type"},
	 { "CallabilitySchedule___getslice__", _wrap_CallabilitySchedule___getslice__, METH_VARARGS, "CallabilitySchedule___getslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j) -> CallabilitySchedule"},
	 { "CallabilitySchedule___setslice__", _wrap_CallabilitySchedule___setslice__, METH_VARARGS, "\n"
		"CallabilitySchedule___setslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j)\n"
		"CallabilitySchedule___setslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j, CallabilitySchedule v)\n"
		""},
	 { "CallabilitySchedule___delslice__", _wrap_CallabilitySchedule___delslice__, METH_VARARGS, "CallabilitySchedule___delslice__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::difference_type j)"},
	 { "CallabilitySchedule___delitem__", _wrap_CallabilitySchedule___delitem__, METH_VARARGS, "\n"
		"CallabilitySchedule___delitem__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i)\n"
		"CallabilitySchedule___delitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "CallabilitySchedule___getitem__", _wrap_CallabilitySchedule___getitem__, METH_VARARGS, "\n"
		"CallabilitySchedule___getitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice) -> CallabilitySchedule\n"
		"CallabilitySchedule___getitem__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i) -> std::vector< ext::shared_ptr< Callability > >::value_type const &\n"
		""},
	 { "CallabilitySchedule___setitem__", _wrap_CallabilitySchedule___setitem__, METH_VARARGS, "\n"
		"CallabilitySchedule___setitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice, CallabilitySchedule v)\n"
		"CallabilitySchedule___setitem__(CallabilitySchedule self, SWIGPY_SLICEOBJECT * slice)\n"
		"CallabilitySchedule___setitem__(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::difference_type i, std::vector< ext::shared_ptr< Callability > >::value_type const & x)\n"
		""},
	 { "CallabilitySchedule_pop", _wrap_CallabilitySchedule_pop, METH_O, "CallabilitySchedule_pop(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::value_type"},
	 { "CallabilitySchedule_append", _wrap_CallabilitySchedule_append, METH_VARARGS, "CallabilitySchedule_append(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::value_type const & x)"},
	 { "CallabilitySchedule_empty", _wrap_CallabilitySchedule_empty, METH_O, "CallabilitySchedule_empty(CallabilitySchedule self) -> bool"},
	 { "CallabilitySchedule_size", _wrap_CallabilitySchedule_size, METH_O, "CallabilitySchedule_size(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::size_type"},
	 { "CallabilitySchedule_swap", _wrap_CallabilitySchedule_swap, METH_VARARGS, "CallabilitySchedule_swap(CallabilitySchedule self, CallabilitySchedule v)"},
	 { "CallabilitySchedule_begin", _wrap_CallabilitySchedule_begin, METH_O, "CallabilitySchedule_begin(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::iterator"},
	 { "CallabilitySchedule_end", _wrap_CallabilitySchedule_end, METH_O, "CallabilitySchedule_end(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::iterator"},
	 { "CallabilitySchedule_rbegin", _wrap_CallabilitySchedule_rbegin, METH_O, "CallabilitySchedule_rbegin(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::reverse_iterator"},
	 { "CallabilitySchedule_rend", _wrap_CallabilitySchedule_rend, METH_O, "CallabilitySchedule_rend(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::reverse_iterator"},
	 { "CallabilitySchedule_clear", _wrap_CallabilitySchedule_clear, METH_O, "CallabilitySchedule_clear(CallabilitySchedule self)"},
	 { "CallabilitySchedule_get_allocator", _wrap_CallabilitySchedule_get_allocator, METH_O, "CallabilitySchedule_get_allocator(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::allocator_type"},
	 { "CallabilitySchedule_pop_back", _wrap_CallabilitySchedule_pop_back, METH_O, "CallabilitySchedule_pop_back(CallabilitySchedule self)"},
	 { "CallabilitySchedule_erase", _wrap_CallabilitySchedule_erase, METH_VARARGS, "\n"
		"CallabilitySchedule_erase(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator pos) -> std::vector< ext::shared_ptr< Callability > >::iterator\n"
		"CallabilitySchedule_erase(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator first, std::vector< ext::shared_ptr< Callability > >::iterator last) -> std::vector< ext::shared_ptr< Callability > >::iterator\n"
		""},
	 { "new_CallabilitySchedule", _wrap_new_CallabilitySchedule, METH_VARARGS, "\n"
		"CallabilitySchedule()\n"
		"CallabilitySchedule(CallabilitySchedule other)\n"
		"CallabilitySchedule(std::vector< ext::shared_ptr< Callability > >::size_type size)\n"
		"new_CallabilitySchedule(std::vector< ext::shared_ptr< Callability > >::size_type size, std::vector< ext::shared_ptr< Callability > >::value_type const & value) -> CallabilitySchedule\n"
		""},
	 { "CallabilitySchedule_push_back", _wrap_CallabilitySchedule_push_back, METH_VARARGS, "CallabilitySchedule_push_back(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::value_type const & x)"},
	 { "CallabilitySchedule_front", _wrap_CallabilitySchedule_front, METH_O, "CallabilitySchedule_front(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::value_type const &"},
	 { "CallabilitySchedule_back", _wrap_CallabilitySchedule_back, METH_O, "CallabilitySchedule_back(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::value_type const &"},
	 { "CallabilitySchedule_assign", _wrap_CallabilitySchedule_assign, METH_VARARGS, "CallabilitySchedule_assign(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type n, std::vector< ext::shared_ptr< Callability > >::value_type const & x)"},
	 { "CallabilitySchedule_resize", _wrap_CallabilitySchedule_resize, METH_VARARGS, "\n"
		"CallabilitySchedule_resize(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type new_size)\n"
		"CallabilitySchedule_resize(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type new_size, std::vector< ext::shared_ptr< Callability > >::value_type const & x)\n"
		""},
	 { "CallabilitySchedule_insert", _wrap_CallabilitySchedule_insert, METH_VARARGS, "\n"
		"CallabilitySchedule_insert(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator pos, std::vector< ext::shared_ptr< Callability > >::value_type const & x) -> std::vector< ext::shared_ptr< Callability > >::iterator\n"
		"CallabilitySchedule_insert(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::iterator pos, std::vector< ext::shared_ptr< Callability > >::size_type n, std::vector< ext::shared_ptr< Callability > >::value_type const & x)\n"
		""},
	 { "CallabilitySchedule_reserve", _wrap_CallabilitySchedule_reserve, METH_VARARGS, "CallabilitySchedule_reserve(CallabilitySchedule self, std::vector< ext::shared_ptr< Callability > >::size_type n)"},
	 { "CallabilitySchedule_capacity", _wrap_CallabilitySchedule_capacity, METH_O, "CallabilitySchedule_capacity(CallabilitySchedule self) -> std::vector< ext::shared_ptr< Callability > >::size_type"},
	 { "delete_CallabilitySchedule", _wrap_delete_CallabilitySchedule, METH_O, "delete_CallabilitySchedule(CallabilitySchedule self)"},
	 { "CallabilitySchedule_swigregister", CallabilitySchedule_swigregister, METH_O, NULL},
	 { "CallabilitySchedule_swiginit", CallabilitySchedule_swiginit, METH_VARARGS, NULL},
	 { "CallableBond_callability", _wrap_CallableBond_callability, METH_O, "CallableBond_callability(CallableBond self) -> CallabilitySchedule"},
	 { "CallableBond_impliedVolatility", _wrap_CallableBond_impliedVolatility, METH_VARARGS, "CallableBond_impliedVolatility(CallableBond self, BondPrice targetPrice, YieldTermStructureHandle discountCurve, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) -> Volatility"},
	 { "CallableBond_OAS", _wrap_CallableBond_OAS, METH_VARARGS, "CallableBond_OAS(CallableBond self, Real cleanPrice, YieldTermStructureHandle engineTS, DayCounter dc, Compounding compounding, Frequency freq, Date settlementDate=Date(), Real accuracy=1e-10, Size maxIterations=100, Spread guess=0.0) -> Real"},
	 { "CallableBond_cleanPriceOAS", _wrap_CallableBond_cleanPriceOAS, METH_VARARGS, "CallableBond_cleanPriceOAS(CallableBond self, Real oas, YieldTermStructureHandle engineTS, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real"},
	 { "CallableBond_effectiveDuration", _wrap_CallableBond_effectiveDuration, METH_VARARGS, "CallableBond_effectiveDuration(CallableBond self, Real oas, YieldTermStructureHandle engineTS, DayCounter dayCounter, Compounding compounding, Frequency frequency, Real bump=2e-4) -> Real"},
	 { "CallableBond_effectiveConvexity", _wrap_CallableBond_effectiveConvexity, METH_VARARGS, "CallableBond_effectiveConvexity(CallableBond self, Real oas, YieldTermStructureHandle engineTS, DayCounter dayCounter, Compounding compounding, Frequency frequency, Real bump=2e-4) -> Real"},
	 { "delete_CallableBond", _wrap_delete_CallableBond, METH_O, "delete_CallableBond(CallableBond self)"},
	 { "CallableBond_swigregister", CallableBond_swigregister, METH_O, NULL},
	 { "new_CallableFixedRateBond", (PyCFunction)(void(*)(void))_wrap_new_CallableFixedRateBond, METH_VARARGS|METH_KEYWORDS, "new_CallableFixedRateBond(Integer settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention, Real redemption, Date issueDate, CallabilitySchedule putCallSchedule, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> CallableFixedRateBond"},
	 { "delete_CallableFixedRateBond", _wrap_delete_CallableFixedRateBond, METH_O, "delete_CallableFixedRateBond(CallableFixedRateBond self)"},
	 { "CallableFixedRateBond_swigregister", CallableFixedRateBond_swigregister, METH_O, NULL},
	 { "CallableFixedRateBond_swiginit", CallableFixedRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_CallableZeroCouponBond", (PyCFunction)(void(*)(void))_wrap_new_CallableZeroCouponBond, METH_VARARGS|METH_KEYWORDS, "new_CallableZeroCouponBond(Integer settlementDays, Real faceAmount, Calendar calendar, Date maturityDate, DayCounter dayCounter, BusinessDayConvention paymentConvention=Following, Real redemption=100.0, Date issueDate=Date(), CallabilitySchedule putCallSchedule=std::vector< ext::shared_ptr< Callability > >()) -> CallableZeroCouponBond"},
	 { "delete_CallableZeroCouponBond", _wrap_delete_CallableZeroCouponBond, METH_O, "delete_CallableZeroCouponBond(CallableZeroCouponBond self)"},
	 { "CallableZeroCouponBond_swigregister", CallableZeroCouponBond_swigregister, METH_O, NULL},
	 { "CallableZeroCouponBond_swiginit", CallableZeroCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_TreeCallableFixedRateBondEngine", _wrap_new_TreeCallableFixedRateBondEngine, METH_VARARGS, "\n"
		"TreeCallableFixedRateBondEngine(ext::shared_ptr< ShortRateModel > const & model, Size timeSteps, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		"TreeCallableFixedRateBondEngine(ext::shared_ptr< ShortRateModel > const & model, TimeGrid grid, YieldTermStructureHandle termStructure=Handle< YieldTermStructure >())\n"
		""},
	 { "delete_TreeCallableFixedRateBondEngine", _wrap_delete_TreeCallableFixedRateBondEngine, METH_O, "delete_TreeCallableFixedRateBondEngine(TreeCallableFixedRateBondEngine self)"},
	 { "TreeCallableFixedRateBondEngine_swigregister", TreeCallableFixedRateBondEngine_swigregister, METH_O, NULL},
	 { "TreeCallableFixedRateBondEngine_swiginit", TreeCallableFixedRateBondEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCallableFixedRateBondEngine", _wrap_new_BlackCallableFixedRateBondEngine, METH_VARARGS, "new_BlackCallableFixedRateBondEngine(QuoteHandle fwdYieldVol, YieldTermStructureHandle discountCurve) -> BlackCallableFixedRateBondEngine"},
	 { "delete_BlackCallableFixedRateBondEngine", _wrap_delete_BlackCallableFixedRateBondEngine, METH_O, "delete_BlackCallableFixedRateBondEngine(BlackCallableFixedRateBondEngine self)"},
	 { "BlackCallableFixedRateBondEngine_swigregister", BlackCallableFixedRateBondEngine_swigregister, METH_O, NULL},
	 { "BlackCallableFixedRateBondEngine_swiginit", BlackCallableFixedRateBondEngine_swiginit, METH_VARARGS, NULL},
	 { "new_CPIBond", (PyCFunction)(void(*)(void))_wrap_new_CPIBond, METH_VARARGS|METH_KEYWORDS, "new_CPIBond(Natural settlementDays, Real faceAmount, bool growthOnly, Real baseCPI, Period observationLag, ext::shared_ptr< ZeroInflationIndex > const & cpiIndex, CPI::InterpolationType observationInterpolation, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention=ModifiedFollowing, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False) -> CPIBond"},
	 { "delete_CPIBond", _wrap_delete_CPIBond, METH_O, "delete_CPIBond(CPIBond self)"},
	 { "CPIBond_swigregister", CPIBond_swigregister, METH_O, NULL},
	 { "CPIBond_swiginit", CPIBond_swiginit, METH_VARARGS, NULL},
	 { "BondFunctions_startDate", _wrap_BondFunctions_startDate, METH_O, "BondFunctions_startDate(Bond bond) -> Date"},
	 { "BondFunctions_maturityDate", _wrap_BondFunctions_maturityDate, METH_O, "BondFunctions_maturityDate(Bond bond) -> Date"},
	 { "BondFunctions_isTradable", _wrap_BondFunctions_isTradable, METH_VARARGS, "BondFunctions_isTradable(Bond bond, Date settlementDate=Date()) -> bool"},
	 { "BondFunctions_previousCashFlowDate", _wrap_BondFunctions_previousCashFlowDate, METH_VARARGS, "BondFunctions_previousCashFlowDate(Bond bond, Date refDate=Date()) -> Date"},
	 { "BondFunctions_nextCashFlowDate", _wrap_BondFunctions_nextCashFlowDate, METH_VARARGS, "BondFunctions_nextCashFlowDate(Bond bond, Date refDate=Date()) -> Date"},
	 { "BondFunctions_previousCashFlowAmount", _wrap_BondFunctions_previousCashFlowAmount, METH_VARARGS, "BondFunctions_previousCashFlowAmount(Bond bond, Date refDate=Date()) -> Real"},
	 { "BondFunctions_nextCashFlowAmount", _wrap_BondFunctions_nextCashFlowAmount, METH_VARARGS, "BondFunctions_nextCashFlowAmount(Bond bond, Date refDate=Date()) -> Real"},
	 { "BondFunctions_previousCouponRate", _wrap_BondFunctions_previousCouponRate, METH_VARARGS, "BondFunctions_previousCouponRate(Bond bond, Date settlementDate=Date()) -> Rate"},
	 { "BondFunctions_nextCouponRate", _wrap_BondFunctions_nextCouponRate, METH_VARARGS, "BondFunctions_nextCouponRate(Bond bond, Date settlementDate=Date()) -> Rate"},
	 { "BondFunctions_accrualStartDate", _wrap_BondFunctions_accrualStartDate, METH_VARARGS, "BondFunctions_accrualStartDate(Bond bond, Date settlementDate=Date()) -> Date"},
	 { "BondFunctions_accrualEndDate", _wrap_BondFunctions_accrualEndDate, METH_VARARGS, "BondFunctions_accrualEndDate(Bond bond, Date settlementDate=Date()) -> Date"},
	 { "BondFunctions_accrualPeriod", _wrap_BondFunctions_accrualPeriod, METH_VARARGS, "BondFunctions_accrualPeriod(Bond bond, Date settlementDate=Date()) -> Time"},
	 { "BondFunctions_accrualDays", _wrap_BondFunctions_accrualDays, METH_VARARGS, "BondFunctions_accrualDays(Bond bond, Date settlementDate=Date()) -> BigInteger"},
	 { "BondFunctions_accruedPeriod", _wrap_BondFunctions_accruedPeriod, METH_VARARGS, "BondFunctions_accruedPeriod(Bond bond, Date settlementDate=Date()) -> Time"},
	 { "BondFunctions_accruedDays", _wrap_BondFunctions_accruedDays, METH_VARARGS, "BondFunctions_accruedDays(Bond bond, Date settlementDate=Date()) -> BigInteger"},
	 { "BondFunctions_accruedAmount", _wrap_BondFunctions_accruedAmount, METH_VARARGS, "BondFunctions_accruedAmount(Bond bond, Date settlementDate=Date()) -> Real"},
	 { "BondFunctions_atmRate", _wrap_BondFunctions_atmRate, METH_VARARGS, "BondFunctions_atmRate(Bond bond, YieldTermStructure discountCurve, Date settlementDate=Date(), Real cleanPrice=Null< Real >()) -> Rate"},
	 { "BondFunctions_cleanPrice", _wrap_BondFunctions_cleanPrice, METH_VARARGS, "\n"
		"BondFunctions_cleanPrice(Bond bond, YieldTermStructure discountCurve, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_cleanPrice(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_cleanPrice(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real\n"
		""},
	 { "BondFunctions_bps", _wrap_BondFunctions_bps, METH_VARARGS, "\n"
		"BondFunctions_bps(Bond bond, YieldTermStructure discountCurve, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_bps(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_bps(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real\n"
		""},
	 { "BondFunctions_bondYield", _wrap_BondFunctions_bondYield, METH_VARARGS, "BondFunctions_bondYield(Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Size maxIterations=100, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_duration", _wrap_BondFunctions_duration, METH_VARARGS, "\n"
		"BondFunctions_duration(Bond bond, InterestRate _yield, Duration::Type type=Modified, Date settlementDate=Date()) -> Time\n"
		"BondFunctions_duration(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Duration::Type type=Modified, Date settlementDate=Date()) -> Time\n"
		""},
	 { "BondFunctions_convexity", _wrap_BondFunctions_convexity, METH_VARARGS, "\n"
		"BondFunctions_convexity(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_convexity(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real\n"
		""},
	 { "BondFunctions_basisPointValue", _wrap_BondFunctions_basisPointValue, METH_VARARGS, "\n"
		"BondFunctions_basisPointValue(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_basisPointValue(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real\n"
		""},
	 { "BondFunctions_yieldValueBasisPoint", _wrap_BondFunctions_yieldValueBasisPoint, METH_VARARGS, "\n"
		"BondFunctions_yieldValueBasisPoint(Bond bond, InterestRate _yield, Date settlementDate=Date()) -> Real\n"
		"BondFunctions_yieldValueBasisPoint(Bond bond, Rate _yield, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date()) -> Real\n"
		""},
	 { "BondFunctions_zSpread", _wrap_BondFunctions_zSpread, METH_VARARGS, "BondFunctions_zSpread(Bond bond, Real cleanPrice, ext::shared_ptr< YieldTermStructure > const & discountCurve, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Size maxIterations=100, Rate guess=0.0) -> Spread"},
	 { "BondFunctions_yieldBrent", _wrap_BondFunctions_yieldBrent, METH_VARARGS, "BondFunctions_yieldBrent(Brent solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_yieldBisection", _wrap_BondFunctions_yieldBisection, METH_VARARGS, "BondFunctions_yieldBisection(Bisection solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_yieldFalsePosition", _wrap_BondFunctions_yieldFalsePosition, METH_VARARGS, "BondFunctions_yieldFalsePosition(FalsePosition solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_yieldRidder", _wrap_BondFunctions_yieldRidder, METH_VARARGS, "BondFunctions_yieldRidder(Ridder solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_yieldSecant", _wrap_BondFunctions_yieldSecant, METH_VARARGS, "BondFunctions_yieldSecant(Secant solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_yieldNewton", _wrap_BondFunctions_yieldNewton, METH_VARARGS, "BondFunctions_yieldNewton(Newton solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "BondFunctions_yieldNewtonSafe", _wrap_BondFunctions_yieldNewtonSafe, METH_VARARGS, "BondFunctions_yieldNewtonSafe(NewtonSafe solver, Bond bond, Real cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlementDate=Date(), Real accuracy=1.0e-10, Rate guess=0.05) -> Rate"},
	 { "new_BondFunctions", _wrap_new_BondFunctions, METH_NOARGS, "new_BondFunctions() -> BondFunctions"},
	 { "delete_BondFunctions", _wrap_delete_BondFunctions, METH_O, "delete_BondFunctions(BondFunctions self)"},
	 { "BondFunctions_swigregister", BondFunctions_swigregister, METH_O, NULL},
	 { "BondFunctions_swiginit", BondFunctions_swiginit, METH_VARARGS, NULL},
	 { "BlackCalibrationHelper_setPricingEngine", _wrap_BlackCalibrationHelper_setPricingEngine, METH_VARARGS, "BlackCalibrationHelper_setPricingEngine(BlackCalibrationHelper self, ext::shared_ptr< PricingEngine > const & engine)"},
	 { "BlackCalibrationHelper_marketValue", _wrap_BlackCalibrationHelper_marketValue, METH_O, "BlackCalibrationHelper_marketValue(BlackCalibrationHelper self) -> Real"},
	 { "BlackCalibrationHelper_modelValue", _wrap_BlackCalibrationHelper_modelValue, METH_O, "BlackCalibrationHelper_modelValue(BlackCalibrationHelper self) -> Real"},
	 { "BlackCalibrationHelper_impliedVolatility", _wrap_BlackCalibrationHelper_impliedVolatility, METH_VARARGS, "BlackCalibrationHelper_impliedVolatility(BlackCalibrationHelper self, Real targetValue, Real accuracy, Size maxEvaluations, Volatility minVol, Volatility maxVol) -> Volatility"},
	 { "BlackCalibrationHelper_blackPrice", _wrap_BlackCalibrationHelper_blackPrice, METH_VARARGS, "BlackCalibrationHelper_blackPrice(BlackCalibrationHelper self, Volatility volatility) -> Real"},
	 { "BlackCalibrationHelper_volatility", _wrap_BlackCalibrationHelper_volatility, METH_O, "BlackCalibrationHelper_volatility(BlackCalibrationHelper self) -> QuoteHandle"},
	 { "BlackCalibrationHelper_volatilityType", _wrap_BlackCalibrationHelper_volatilityType, METH_O, "BlackCalibrationHelper_volatilityType(BlackCalibrationHelper self) -> VolatilityType"},
	 { "BlackCalibrationHelper_calibrationError", _wrap_BlackCalibrationHelper_calibrationError, METH_O, "BlackCalibrationHelper_calibrationError(BlackCalibrationHelper self) -> Real"},
	 { "delete_BlackCalibrationHelper", _wrap_delete_BlackCalibrationHelper, METH_O, "delete_BlackCalibrationHelper(BlackCalibrationHelper self)"},
	 { "BlackCalibrationHelper_swigregister", BlackCalibrationHelper_swigregister, METH_O, NULL},
	 { "as_black_helper", _wrap_as_black_helper, METH_O, "as_black_helper(ext::shared_ptr< CalibrationHelper > const & h) -> ext::shared_ptr< BlackCalibrationHelper >"},
	 { "as_swaption_helper", _wrap_as_swaption_helper, METH_O, "as_swaption_helper(ext::shared_ptr< BlackCalibrationHelper > const & h) -> ext::shared_ptr< SwaptionHelper >"},
	 { "new_SwaptionHelper", _wrap_new_SwaptionHelper, METH_VARARGS, "\n"
		"SwaptionHelper(Period maturity, Period length, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, Real const strike=Null< Real >(), Real const nominal=1.0, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"SwaptionHelper(Date exerciseDate, Period length, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, Real const strike=Null< Real >(), Real const nominal=1.0, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		"SwaptionHelper(Date exerciseDate, Date endDate, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Period fixedLegTenor, DayCounter fixedLegDayCounter, DayCounter floatingLegDayCounter, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, Real const strike=Null< Real >(), Real const nominal=1.0, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)\n"
		""},
	 { "SwaptionHelper_underlyingSwap", _wrap_SwaptionHelper_underlyingSwap, METH_O, "SwaptionHelper_underlyingSwap(SwaptionHelper self) -> ext::shared_ptr< VanillaSwap >"},
	 { "SwaptionHelper_swaption", _wrap_SwaptionHelper_swaption, METH_O, "SwaptionHelper_swaption(SwaptionHelper self) -> ext::shared_ptr< Swaption >"},
	 { "SwaptionHelper_times", _wrap_SwaptionHelper_times, METH_O, "SwaptionHelper_times(SwaptionHelper self) -> DoubleVector"},
	 { "SwaptionHelper_swaptionExpiryDate", _wrap_SwaptionHelper_swaptionExpiryDate, METH_O, "SwaptionHelper_swaptionExpiryDate(SwaptionHelper self) -> Date"},
	 { "SwaptionHelper_swaptionStrike", _wrap_SwaptionHelper_swaptionStrike, METH_O, "SwaptionHelper_swaptionStrike(SwaptionHelper self) -> Real"},
	 { "SwaptionHelper_swaptionNominal", _wrap_SwaptionHelper_swaptionNominal, METH_O, "SwaptionHelper_swaptionNominal(SwaptionHelper self) -> Real"},
	 { "SwaptionHelper_swaptionMaturityDate", _wrap_SwaptionHelper_swaptionMaturityDate, METH_O, "SwaptionHelper_swaptionMaturityDate(SwaptionHelper self) -> Date"},
	 { "delete_SwaptionHelper", _wrap_delete_SwaptionHelper, METH_O, "delete_SwaptionHelper(SwaptionHelper self)"},
	 { "SwaptionHelper_swigregister", SwaptionHelper_swigregister, METH_O, NULL},
	 { "SwaptionHelper_swiginit", SwaptionHelper_swiginit, METH_VARARGS, NULL},
	 { "new_CapHelper", _wrap_new_CapHelper, METH_VARARGS, "CapHelper(Period length, QuoteHandle volatility, ext::shared_ptr< IborIndex > const & index, Frequency fixedLegFrequency, DayCounter fixedLegDayCounter, bool includeFirstSwaplet, YieldTermStructureHandle termStructure, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError, VolatilityType const type=ShiftedLognormal, Real const shift=0.0)"},
	 { "CapHelper_times", _wrap_CapHelper_times, METH_O, "CapHelper_times(CapHelper self) -> DoubleVector"},
	 { "delete_CapHelper", _wrap_delete_CapHelper, METH_O, "delete_CapHelper(CapHelper self)"},
	 { "CapHelper_swigregister", CapHelper_swigregister, METH_O, NULL},
	 { "CapHelper_swiginit", CapHelper_swiginit, METH_VARARGS, NULL},
	 { "new_HestonModelHelper", _wrap_new_HestonModelHelper, METH_VARARGS, "HestonModelHelper(Period maturity, Calendar calendar, Real const s0, Real const strikePrice, QuoteHandle volatility, YieldTermStructureHandle riskFreeRate, YieldTermStructureHandle dividendYield, BlackCalibrationHelper::CalibrationErrorType errorType=RelativePriceError)"},
	 { "delete_HestonModelHelper", _wrap_delete_HestonModelHelper, METH_O, "delete_HestonModelHelper(HestonModelHelper self)"},
	 { "HestonModelHelper_swigregister", HestonModelHelper_swigregister, METH_O, NULL},
	 { "HestonModelHelper_swiginit", HestonModelHelper_swiginit, METH_VARARGS, NULL},
	 { "BlackCalibrationHelperVector_iterator", _wrap_BlackCalibrationHelperVector_iterator, METH_O, "BlackCalibrationHelperVector_iterator(BlackCalibrationHelperVector self) -> SwigPyIterator"},
	 { "BlackCalibrationHelperVector___nonzero__", _wrap_BlackCalibrationHelperVector___nonzero__, METH_O, "BlackCalibrationHelperVector___nonzero__(BlackCalibrationHelperVector self) -> bool"},
	 { "BlackCalibrationHelperVector___bool__", _wrap_BlackCalibrationHelperVector___bool__, METH_O, "BlackCalibrationHelperVector___bool__(BlackCalibrationHelperVector self) -> bool"},
	 { "BlackCalibrationHelperVector___len__", _wrap_BlackCalibrationHelperVector___len__, METH_O, "BlackCalibrationHelperVector___len__(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type"},
	 { "BlackCalibrationHelperVector___getslice__", _wrap_BlackCalibrationHelperVector___getslice__, METH_VARARGS, "BlackCalibrationHelperVector___getslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j) -> BlackCalibrationHelperVector"},
	 { "BlackCalibrationHelperVector___setslice__", _wrap_BlackCalibrationHelperVector___setslice__, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector___setslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j)\n"
		"BlackCalibrationHelperVector___setslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j, BlackCalibrationHelperVector v)\n"
		""},
	 { "BlackCalibrationHelperVector___delslice__", _wrap_BlackCalibrationHelperVector___delslice__, METH_VARARGS, "BlackCalibrationHelperVector___delslice__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type j)"},
	 { "BlackCalibrationHelperVector___delitem__", _wrap_BlackCalibrationHelperVector___delitem__, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector___delitem__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i)\n"
		"BlackCalibrationHelperVector___delitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "BlackCalibrationHelperVector___getitem__", _wrap_BlackCalibrationHelperVector___getitem__, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector___getitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice) -> BlackCalibrationHelperVector\n"
		"BlackCalibrationHelperVector___getitem__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &\n"
		""},
	 { "BlackCalibrationHelperVector___setitem__", _wrap_BlackCalibrationHelperVector___setitem__, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector___setitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice, BlackCalibrationHelperVector v)\n"
		"BlackCalibrationHelperVector___setitem__(BlackCalibrationHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"BlackCalibrationHelperVector___setitem__(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::difference_type i, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)\n"
		""},
	 { "BlackCalibrationHelperVector_pop", _wrap_BlackCalibrationHelperVector_pop, METH_O, "BlackCalibrationHelperVector_pop(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type"},
	 { "BlackCalibrationHelperVector_append", _wrap_BlackCalibrationHelperVector_append, METH_VARARGS, "BlackCalibrationHelperVector_append(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)"},
	 { "BlackCalibrationHelperVector_empty", _wrap_BlackCalibrationHelperVector_empty, METH_O, "BlackCalibrationHelperVector_empty(BlackCalibrationHelperVector self) -> bool"},
	 { "BlackCalibrationHelperVector_size", _wrap_BlackCalibrationHelperVector_size, METH_O, "BlackCalibrationHelperVector_size(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type"},
	 { "BlackCalibrationHelperVector_swap", _wrap_BlackCalibrationHelperVector_swap, METH_VARARGS, "BlackCalibrationHelperVector_swap(BlackCalibrationHelperVector self, BlackCalibrationHelperVector v)"},
	 { "BlackCalibrationHelperVector_begin", _wrap_BlackCalibrationHelperVector_begin, METH_O, "BlackCalibrationHelperVector_begin(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator"},
	 { "BlackCalibrationHelperVector_end", _wrap_BlackCalibrationHelperVector_end, METH_O, "BlackCalibrationHelperVector_end(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator"},
	 { "BlackCalibrationHelperVector_rbegin", _wrap_BlackCalibrationHelperVector_rbegin, METH_O, "BlackCalibrationHelperVector_rbegin(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator"},
	 { "BlackCalibrationHelperVector_rend", _wrap_BlackCalibrationHelperVector_rend, METH_O, "BlackCalibrationHelperVector_rend(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::reverse_iterator"},
	 { "BlackCalibrationHelperVector_clear", _wrap_BlackCalibrationHelperVector_clear, METH_O, "BlackCalibrationHelperVector_clear(BlackCalibrationHelperVector self)"},
	 { "BlackCalibrationHelperVector_get_allocator", _wrap_BlackCalibrationHelperVector_get_allocator, METH_O, "BlackCalibrationHelperVector_get_allocator(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::allocator_type"},
	 { "BlackCalibrationHelperVector_pop_back", _wrap_BlackCalibrationHelperVector_pop_back, METH_O, "BlackCalibrationHelperVector_pop_back(BlackCalibrationHelperVector self)"},
	 { "BlackCalibrationHelperVector_erase", _wrap_BlackCalibrationHelperVector_erase, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector_erase(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator\n"
		"BlackCalibrationHelperVector_erase(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator first, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator last) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator\n"
		""},
	 { "new_BlackCalibrationHelperVector", _wrap_new_BlackCalibrationHelperVector, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector()\n"
		"BlackCalibrationHelperVector(BlackCalibrationHelperVector other)\n"
		"BlackCalibrationHelperVector(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type size)\n"
		"new_BlackCalibrationHelperVector(std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type size, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & value) -> BlackCalibrationHelperVector\n"
		""},
	 { "BlackCalibrationHelperVector_push_back", _wrap_BlackCalibrationHelperVector_push_back, METH_VARARGS, "BlackCalibrationHelperVector_push_back(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)"},
	 { "BlackCalibrationHelperVector_front", _wrap_BlackCalibrationHelperVector_front, METH_O, "BlackCalibrationHelperVector_front(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &"},
	 { "BlackCalibrationHelperVector_back", _wrap_BlackCalibrationHelperVector_back, METH_O, "BlackCalibrationHelperVector_back(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const &"},
	 { "BlackCalibrationHelperVector_assign", _wrap_BlackCalibrationHelperVector_assign, METH_VARARGS, "BlackCalibrationHelperVector_assign(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)"},
	 { "BlackCalibrationHelperVector_resize", _wrap_BlackCalibrationHelperVector_resize, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector_resize(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type new_size)\n"
		"BlackCalibrationHelperVector_resize(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type new_size, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)\n"
		""},
	 { "BlackCalibrationHelperVector_insert", _wrap_BlackCalibrationHelperVector_insert, METH_VARARGS, "\n"
		"BlackCalibrationHelperVector_insert(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator\n"
		"BlackCalibrationHelperVector_insert(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::iterator pos, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::value_type const & x)\n"
		""},
	 { "BlackCalibrationHelperVector_reserve", _wrap_BlackCalibrationHelperVector_reserve, METH_VARARGS, "BlackCalibrationHelperVector_reserve(BlackCalibrationHelperVector self, std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type n)"},
	 { "BlackCalibrationHelperVector_capacity", _wrap_BlackCalibrationHelperVector_capacity, METH_O, "BlackCalibrationHelperVector_capacity(BlackCalibrationHelperVector self) -> std::vector< ext::shared_ptr< BlackCalibrationHelper > >::size_type"},
	 { "delete_BlackCalibrationHelperVector", _wrap_delete_BlackCalibrationHelperVector, METH_O, "delete_BlackCalibrationHelperVector(BlackCalibrationHelperVector self)"},
	 { "BlackCalibrationHelperVector_swigregister", BlackCalibrationHelperVector_swigregister, METH_O, NULL},
	 { "BlackCalibrationHelperVector_swiginit", BlackCalibrationHelperVector_swiginit, METH_VARARGS, NULL},
	 { "CapFloor_impliedVolatility", _wrap_CapFloor_impliedVolatility, METH_VARARGS, "CapFloor_impliedVolatility(CapFloor self, Real price, YieldTermStructureHandle disc, Volatility guess, Real accuracy=1.0e-4, Natural maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0, VolatilityType type=ShiftedLognormal, Real displacement=0.0) -> Volatility"},
	 { "CapFloor_floatingLeg", _wrap_CapFloor_floatingLeg, METH_O, "CapFloor_floatingLeg(CapFloor self) -> Leg"},
	 { "CapFloor_capRates", _wrap_CapFloor_capRates, METH_O, "CapFloor_capRates(CapFloor self) -> DoubleVector"},
	 { "CapFloor_floorRates", _wrap_CapFloor_floorRates, METH_O, "CapFloor_floorRates(CapFloor self) -> DoubleVector"},
	 { "CapFloor_startDate", _wrap_CapFloor_startDate, METH_O, "CapFloor_startDate(CapFloor self) -> Date"},
	 { "CapFloor_maturityDate", _wrap_CapFloor_maturityDate, METH_O, "CapFloor_maturityDate(CapFloor self) -> Date"},
	 { "CapFloor_type", _wrap_CapFloor_type, METH_O, "CapFloor_type(CapFloor self) -> CapFloor::Type"},
	 { "CapFloor_atmRate", _wrap_CapFloor_atmRate, METH_VARARGS, "CapFloor_atmRate(CapFloor self, YieldTermStructure discountCurve) -> Rate"},
	 { "CapFloor_vega", _wrap_CapFloor_vega, METH_O, "CapFloor_vega(CapFloor self) -> Real const"},
	 { "CapFloor_optionletsPrice", _wrap_CapFloor_optionletsPrice, METH_O, "CapFloor_optionletsPrice(CapFloor self) -> DoubleVector"},
	 { "CapFloor_optionletsVega", _wrap_CapFloor_optionletsVega, METH_O, "CapFloor_optionletsVega(CapFloor self) -> DoubleVector"},
	 { "CapFloor_optionletsDelta", _wrap_CapFloor_optionletsDelta, METH_O, "CapFloor_optionletsDelta(CapFloor self) -> DoubleVector"},
	 { "CapFloor_optionletsDiscountFactor", _wrap_CapFloor_optionletsDiscountFactor, METH_O, "CapFloor_optionletsDiscountFactor(CapFloor self) -> DoubleVector"},
	 { "CapFloor_optionletsAtmForward", _wrap_CapFloor_optionletsAtmForward, METH_O, "CapFloor_optionletsAtmForward(CapFloor self) -> DoubleVector"},
	 { "CapFloor_optionletsStdDev", _wrap_CapFloor_optionletsStdDev, METH_O, "CapFloor_optionletsStdDev(CapFloor self) -> DoubleVector"},
	 { "delete_CapFloor", _wrap_delete_CapFloor, METH_O, "delete_CapFloor(CapFloor self)"},
	 { "CapFloor_swigregister", CapFloor_swigregister, METH_O, NULL},
	 { "new_Cap", _wrap_new_Cap, METH_VARARGS, "new_Cap(Leg leg, DoubleVector capRates) -> Cap"},
	 { "delete_Cap", _wrap_delete_Cap, METH_O, "delete_Cap(Cap self)"},
	 { "Cap_swigregister", Cap_swigregister, METH_O, NULL},
	 { "Cap_swiginit", Cap_swiginit, METH_VARARGS, NULL},
	 { "new_Floor", _wrap_new_Floor, METH_VARARGS, "new_Floor(Leg leg, DoubleVector floorRates) -> Floor"},
	 { "delete_Floor", _wrap_delete_Floor, METH_O, "delete_Floor(Floor self)"},
	 { "Floor_swigregister", Floor_swigregister, METH_O, NULL},
	 { "Floor_swiginit", Floor_swiginit, METH_VARARGS, NULL},
	 { "new_Collar", _wrap_new_Collar, METH_VARARGS, "new_Collar(Leg leg, DoubleVector capRates, DoubleVector floorRates) -> Collar"},
	 { "delete_Collar", _wrap_delete_Collar, METH_O, "delete_Collar(Collar self)"},
	 { "Collar_swigregister", Collar_swigregister, METH_O, NULL},
	 { "Collar_swiginit", Collar_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCapFloorEngine", _wrap_new_BlackCapFloorEngine, METH_VARARGS, "\n"
		"BlackCapFloorEngine(YieldTermStructureHandle termStructure, QuoteHandle vol, DayCounter dc=Actual365Fixed(), Real displacement=0.0)\n"
		"BlackCapFloorEngine(YieldTermStructureHandle termStructure, OptionletVolatilityStructureHandle vol, Real displacement=Null< Real >())\n"
		""},
	 { "delete_BlackCapFloorEngine", _wrap_delete_BlackCapFloorEngine, METH_O, "delete_BlackCapFloorEngine(BlackCapFloorEngine self)"},
	 { "BlackCapFloorEngine_swigregister", BlackCapFloorEngine_swigregister, METH_O, NULL},
	 { "BlackCapFloorEngine_swiginit", BlackCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BachelierCapFloorEngine", _wrap_new_BachelierCapFloorEngine, METH_VARARGS, "\n"
		"BachelierCapFloorEngine(YieldTermStructureHandle termStructure, QuoteHandle vol)\n"
		"new_BachelierCapFloorEngine(YieldTermStructureHandle termStructure, OptionletVolatilityStructureHandle vol) -> BachelierCapFloorEngine\n"
		""},
	 { "delete_BachelierCapFloorEngine", _wrap_delete_BachelierCapFloorEngine, METH_O, "delete_BachelierCapFloorEngine(BachelierCapFloorEngine self)"},
	 { "BachelierCapFloorEngine_swigregister", BachelierCapFloorEngine_swigregister, METH_O, NULL},
	 { "BachelierCapFloorEngine_swiginit", BachelierCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_CliquetOption", _wrap_new_CliquetOption, METH_VARARGS, "new_CliquetOption(ext::shared_ptr< PercentageStrikePayoff > const & payoff, ext::shared_ptr< EuropeanExercise > const & maturity, DateVector resetDates) -> CliquetOption"},
	 { "delete_CliquetOption", _wrap_delete_CliquetOption, METH_O, "delete_CliquetOption(CliquetOption self)"},
	 { "CliquetOption_swigregister", CliquetOption_swigregister, METH_O, NULL},
	 { "CliquetOption_swiginit", CliquetOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticCliquetEngine", _wrap_new_AnalyticCliquetEngine, METH_O, "new_AnalyticCliquetEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticCliquetEngine"},
	 { "delete_AnalyticCliquetEngine", _wrap_delete_AnalyticCliquetEngine, METH_O, "delete_AnalyticCliquetEngine(AnalyticCliquetEngine self)"},
	 { "AnalyticCliquetEngine_swigregister", AnalyticCliquetEngine_swigregister, METH_O, NULL},
	 { "AnalyticCliquetEngine_swiginit", AnalyticCliquetEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticPerformanceEngine", _wrap_new_AnalyticPerformanceEngine, METH_O, "new_AnalyticPerformanceEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const process) -> AnalyticPerformanceEngine"},
	 { "delete_AnalyticPerformanceEngine", _wrap_delete_AnalyticPerformanceEngine, METH_O, "delete_AnalyticPerformanceEngine(AnalyticPerformanceEngine self)"},
	 { "AnalyticPerformanceEngine_swigregister", AnalyticPerformanceEngine_swigregister, METH_O, NULL},
	 { "AnalyticPerformanceEngine_swiginit", AnalyticPerformanceEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCPRPerformanceEngine", (PyCFunction)(void(*)(void))_wrap_new_MCPRPerformanceEngine, METH_VARARGS|METH_KEYWORDS, "new_MCPRPerformanceEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCPRPerformanceEngine"},
	 { "delete_MCPRPerformanceEngine", _wrap_delete_MCPRPerformanceEngine, METH_O, "delete_MCPRPerformanceEngine(MCPRPerformanceEngine self)"},
	 { "MCPRPerformanceEngine_swigregister", MCPRPerformanceEngine_swigregister, METH_O, NULL},
	 { "MCPRPerformanceEngine_swiginit", MCPRPerformanceEngine_swiginit, METH_VARARGS, NULL},
	 { "new_MCLDPerformanceEngine", (PyCFunction)(void(*)(void))_wrap_new_MCLDPerformanceEngine, METH_VARARGS|METH_KEYWORDS, "new_MCLDPerformanceEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > process, bool brownianBridge=False, bool antitheticVariate=False, intOrNull requiredSamples=Null< Size >(), doubleOrNull requiredTolerance=Null< Real >(), intOrNull maxSamples=Null< Size >(), BigInteger seed=0) -> MCLDPerformanceEngine"},
	 { "delete_MCLDPerformanceEngine", _wrap_delete_MCLDPerformanceEngine, METH_O, "delete_MCLDPerformanceEngine(MCLDPerformanceEngine self)"},
	 { "MCLDPerformanceEngine_swigregister", MCLDPerformanceEngine_swigregister, METH_O, NULL},
	 { "MCLDPerformanceEngine_swiginit", MCLDPerformanceEngine_swiginit, METH_VARARGS, NULL},
	 { "new_ConvertibleZeroCouponBond", _wrap_new_ConvertibleZeroCouponBond, METH_VARARGS, "ConvertibleZeroCouponBond(ext::shared_ptr< Exercise > const & exercise, Real conversionRatio, CallabilitySchedule callability, Date issueDate, Integer settlementDays, DayCounter dayCounter, Schedule schedule, Real redemption=100.0)"},
	 { "delete_ConvertibleZeroCouponBond", _wrap_delete_ConvertibleZeroCouponBond, METH_O, "delete_ConvertibleZeroCouponBond(ConvertibleZeroCouponBond self)"},
	 { "ConvertibleZeroCouponBond_swigregister", ConvertibleZeroCouponBond_swigregister, METH_O, NULL},
	 { "ConvertibleZeroCouponBond_swiginit", ConvertibleZeroCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_ConvertibleFixedCouponBond", _wrap_new_ConvertibleFixedCouponBond, METH_VARARGS, "ConvertibleFixedCouponBond(ext::shared_ptr< Exercise > const & exercise, Real conversionRatio, CallabilitySchedule callability, Date issueDate, Integer settlementDays, DoubleVector coupons, DayCounter dayCounter, Schedule schedule, Real redemption=100.0, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False)"},
	 { "delete_ConvertibleFixedCouponBond", _wrap_delete_ConvertibleFixedCouponBond, METH_O, "delete_ConvertibleFixedCouponBond(ConvertibleFixedCouponBond self)"},
	 { "ConvertibleFixedCouponBond_swigregister", ConvertibleFixedCouponBond_swigregister, METH_O, NULL},
	 { "ConvertibleFixedCouponBond_swiginit", ConvertibleFixedCouponBond_swiginit, METH_VARARGS, NULL},
	 { "new_ConvertibleFloatingRateBond", _wrap_new_ConvertibleFloatingRateBond, METH_VARARGS, "ConvertibleFloatingRateBond(ext::shared_ptr< Exercise > const & exercise, Real conversionRatio, CallabilitySchedule callability, Date issueDate, Integer settlementDays, ext::shared_ptr< IborIndex > const & index, Integer fixingDays, DoubleVector spreads, DayCounter dayCounter, Schedule schedule, Real redemption=100.0, Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention const exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False)"},
	 { "delete_ConvertibleFloatingRateBond", _wrap_delete_ConvertibleFloatingRateBond, METH_O, "delete_ConvertibleFloatingRateBond(ConvertibleFloatingRateBond self)"},
	 { "ConvertibleFloatingRateBond_swigregister", ConvertibleFloatingRateBond_swigregister, METH_O, NULL},
	 { "ConvertibleFloatingRateBond_swiginit", ConvertibleFloatingRateBond_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialCRRConvertibleEngine", _wrap_new_BinomialCRRConvertibleEngine, METH_VARARGS, "BinomialCRRConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialCRRConvertibleEngine", _wrap_delete_BinomialCRRConvertibleEngine, METH_O, "delete_BinomialCRRConvertibleEngine(BinomialCRRConvertibleEngine self)"},
	 { "BinomialCRRConvertibleEngine_swigregister", BinomialCRRConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialCRRConvertibleEngine_swiginit", BinomialCRRConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJRConvertibleEngine", _wrap_new_BinomialJRConvertibleEngine, METH_VARARGS, "BinomialJRConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialJRConvertibleEngine", _wrap_delete_BinomialJRConvertibleEngine, METH_O, "delete_BinomialJRConvertibleEngine(BinomialJRConvertibleEngine self)"},
	 { "BinomialJRConvertibleEngine_swigregister", BinomialJRConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialJRConvertibleEngine_swiginit", BinomialJRConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialEQPConvertibleEngine", _wrap_new_BinomialEQPConvertibleEngine, METH_VARARGS, "BinomialEQPConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialEQPConvertibleEngine", _wrap_delete_BinomialEQPConvertibleEngine, METH_O, "delete_BinomialEQPConvertibleEngine(BinomialEQPConvertibleEngine self)"},
	 { "BinomialEQPConvertibleEngine_swigregister", BinomialEQPConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialEQPConvertibleEngine_swiginit", BinomialEQPConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTrigeorgisConvertibleEngine", _wrap_new_BinomialTrigeorgisConvertibleEngine, METH_VARARGS, "BinomialTrigeorgisConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialTrigeorgisConvertibleEngine", _wrap_delete_BinomialTrigeorgisConvertibleEngine, METH_O, "delete_BinomialTrigeorgisConvertibleEngine(BinomialTrigeorgisConvertibleEngine self)"},
	 { "BinomialTrigeorgisConvertibleEngine_swigregister", BinomialTrigeorgisConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialTrigeorgisConvertibleEngine_swiginit", BinomialTrigeorgisConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialTianConvertibleEngine", _wrap_new_BinomialTianConvertibleEngine, METH_VARARGS, "BinomialTianConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialTianConvertibleEngine", _wrap_delete_BinomialTianConvertibleEngine, METH_O, "delete_BinomialTianConvertibleEngine(BinomialTianConvertibleEngine self)"},
	 { "BinomialTianConvertibleEngine_swigregister", BinomialTianConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialTianConvertibleEngine_swiginit", BinomialTianConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialLRConvertibleEngine", _wrap_new_BinomialLRConvertibleEngine, METH_VARARGS, "BinomialLRConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialLRConvertibleEngine", _wrap_delete_BinomialLRConvertibleEngine, METH_O, "delete_BinomialLRConvertibleEngine(BinomialLRConvertibleEngine self)"},
	 { "BinomialLRConvertibleEngine_swigregister", BinomialLRConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialLRConvertibleEngine_swiginit", BinomialLRConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialJ4ConvertibleEngine", _wrap_new_BinomialJ4ConvertibleEngine, METH_VARARGS, "BinomialJ4ConvertibleEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > arg1, Size steps, QuoteHandle creditSpread, DividendSchedule dividends=std::vector< ext::shared_ptr< Dividend > >())"},
	 { "delete_BinomialJ4ConvertibleEngine", _wrap_delete_BinomialJ4ConvertibleEngine, METH_O, "delete_BinomialJ4ConvertibleEngine(BinomialJ4ConvertibleEngine self)"},
	 { "BinomialJ4ConvertibleEngine_swigregister", BinomialJ4ConvertibleEngine_swigregister, METH_O, NULL},
	 { "BinomialJ4ConvertibleEngine_swiginit", BinomialJ4ConvertibleEngine_swiginit, METH_VARARGS, NULL},
	 { "Forward_settlementDate", _wrap_Forward_settlementDate, METH_O, "Forward_settlementDate(Forward self) -> Date"},
	 { "Forward_isExpired", _wrap_Forward_isExpired, METH_O, "Forward_isExpired(Forward self) -> bool"},
	 { "Forward_calendar", _wrap_Forward_calendar, METH_O, "Forward_calendar(Forward self) -> Calendar"},
	 { "Forward_businessDayConvention", _wrap_Forward_businessDayConvention, METH_O, "Forward_businessDayConvention(Forward self) -> BusinessDayConvention"},
	 { "Forward_dayCounter", _wrap_Forward_dayCounter, METH_O, "Forward_dayCounter(Forward self) -> DayCounter"},
	 { "Forward_discountCurve", _wrap_Forward_discountCurve, METH_O, "Forward_discountCurve(Forward self) -> YieldTermStructureHandle"},
	 { "Forward_incomeDiscountCurve", _wrap_Forward_incomeDiscountCurve, METH_O, "Forward_incomeDiscountCurve(Forward self) -> YieldTermStructureHandle"},
	 { "Forward_spotValue", _wrap_Forward_spotValue, METH_O, "Forward_spotValue(Forward self) -> Real"},
	 { "Forward_spotIncome", _wrap_Forward_spotIncome, METH_VARARGS, "Forward_spotIncome(Forward self, YieldTermStructureHandle incomeDiscountCurve) -> Real"},
	 { "Forward_forwardValue", _wrap_Forward_forwardValue, METH_O, "Forward_forwardValue(Forward self) -> Real"},
	 { "Forward_impliedYield", _wrap_Forward_impliedYield, METH_VARARGS, "Forward_impliedYield(Forward self, Real underlyingSpotValue, Real forwardValue, Date settlementDate, Compounding compoundingConvention, DayCounter dayCounter) -> InterestRate"},
	 { "delete_Forward", _wrap_delete_Forward, METH_O, "delete_Forward(Forward self)"},
	 { "Forward_swigregister", Forward_swigregister, METH_O, NULL},
	 { "new_BondForward", _wrap_new_BondForward, METH_VARARGS, "BondForward(Date valueDate, Date maturityDate, Position::Type type, Real strike, Natural settlementDays, DayCounter dayCounter, Calendar calendar, BusinessDayConvention businessDayConvention, ext::shared_ptr< Bond > const & bond, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), YieldTermStructureHandle incomeDiscountCurve=Handle< YieldTermStructure >())"},
	 { "BondForward_forwardPrice", _wrap_BondForward_forwardPrice, METH_O, "BondForward_forwardPrice(BondForward self) -> Real"},
	 { "BondForward_cleanForwardPrice", _wrap_BondForward_cleanForwardPrice, METH_O, "BondForward_cleanForwardPrice(BondForward self) -> Real"},
	 { "delete_BondForward", _wrap_delete_BondForward, METH_O, "delete_BondForward(BondForward self)"},
	 { "BondForward_swigregister", BondForward_swigregister, METH_O, NULL},
	 { "BondForward_swiginit", BondForward_swiginit, METH_VARARGS, NULL},
	 { "new_FixedRateBondForward", _wrap_new_FixedRateBondForward, METH_VARARGS, "FixedRateBondForward(Date valueDate, Date maturityDate, Position::Type type, Real strike, Natural settlementDays, DayCounter dayCounter, Calendar calendar, BusinessDayConvention businessDayConvention, ext::shared_ptr< FixedRateBond > const & fixedBond, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), YieldTermStructureHandle incomeDiscountCurve=Handle< YieldTermStructure >())"},
	 { "delete_FixedRateBondForward", _wrap_delete_FixedRateBondForward, METH_O, "delete_FixedRateBondForward(FixedRateBondForward self)"},
	 { "FixedRateBondForward_swigregister", FixedRateBondForward_swigregister, METH_O, NULL},
	 { "FixedRateBondForward_swiginit", FixedRateBondForward_swiginit, METH_VARARGS, NULL},
	 { "new_Futures", _wrap_new_Futures, METH_NOARGS, "new_Futures() -> Futures"},
	 { "delete_Futures", _wrap_delete_Futures, METH_O, "delete_Futures(Futures self)"},
	 { "Futures_swigregister", Futures_swigregister, METH_O, NULL},
	 { "Futures_swiginit", Futures_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexFuture", _wrap_new_OvernightIndexFuture, METH_VARARGS, "OvernightIndexFuture(ext::shared_ptr< OvernightIndex > overnightIndex, Date valueDate, Date maturityDate, QuoteHandle convexityAdjustment=Handle< Quote >(), RateAveraging::Type averagingMethod=Compound)"},
	 { "OvernightIndexFuture_convexityAdjustment", _wrap_OvernightIndexFuture_convexityAdjustment, METH_O, "OvernightIndexFuture_convexityAdjustment(OvernightIndexFuture self) -> Real"},
	 { "delete_OvernightIndexFuture", _wrap_delete_OvernightIndexFuture, METH_O, "delete_OvernightIndexFuture(OvernightIndexFuture self)"},
	 { "OvernightIndexFuture_swigregister", OvernightIndexFuture_swigregister, METH_O, NULL},
	 { "OvernightIndexFuture_swiginit", OvernightIndexFuture_swiginit, METH_VARARGS, NULL},
	 { "new_Pillar", _wrap_new_Pillar, METH_NOARGS, "new_Pillar() -> Pillar"},
	 { "delete_Pillar", _wrap_delete_Pillar, METH_O, "delete_Pillar(Pillar self)"},
	 { "Pillar_swigregister", Pillar_swigregister, METH_O, NULL},
	 { "Pillar_swiginit", Pillar_swiginit, METH_VARARGS, NULL},
	 { "RateHelper_quote", _wrap_RateHelper_quote, METH_O, "RateHelper_quote(RateHelper self) -> QuoteHandle"},
	 { "RateHelper_latestDate", _wrap_RateHelper_latestDate, METH_O, "RateHelper_latestDate(RateHelper self) -> Date"},
	 { "RateHelper_earliestDate", _wrap_RateHelper_earliestDate, METH_O, "RateHelper_earliestDate(RateHelper self) -> Date"},
	 { "RateHelper_maturityDate", _wrap_RateHelper_maturityDate, METH_O, "RateHelper_maturityDate(RateHelper self) -> Date"},
	 { "RateHelper_latestRelevantDate", _wrap_RateHelper_latestRelevantDate, METH_O, "RateHelper_latestRelevantDate(RateHelper self) -> Date"},
	 { "RateHelper_pillarDate", _wrap_RateHelper_pillarDate, METH_O, "RateHelper_pillarDate(RateHelper self) -> Date"},
	 { "RateHelper_impliedQuote", _wrap_RateHelper_impliedQuote, METH_O, "RateHelper_impliedQuote(RateHelper self) -> Real"},
	 { "RateHelper_quoteError", _wrap_RateHelper_quoteError, METH_O, "RateHelper_quoteError(RateHelper self) -> Real"},
	 { "delete_RateHelper", _wrap_delete_RateHelper, METH_O, "delete_RateHelper(RateHelper self)"},
	 { "RateHelper_swigregister", RateHelper_swigregister, METH_O, NULL},
	 { "new_DepositRateHelper", _wrap_new_DepositRateHelper, METH_VARARGS, "\n"
		"DepositRateHelper(QuoteHandle rate, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter)\n"
		"DepositRateHelper(Rate rate, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter)\n"
		"DepositRateHelper(QuoteHandle rate, ext::shared_ptr< IborIndex > const & index)\n"
		"new_DepositRateHelper(Rate rate, ext::shared_ptr< IborIndex > const & index) -> DepositRateHelper\n"
		""},
	 { "delete_DepositRateHelper", _wrap_delete_DepositRateHelper, METH_O, "delete_DepositRateHelper(DepositRateHelper self)"},
	 { "DepositRateHelper_swigregister", DepositRateHelper_swigregister, METH_O, NULL},
	 { "DepositRateHelper_swiginit", DepositRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FraRateHelper", _wrap_new_FraRateHelper, METH_VARARGS, "\n"
		"FraRateHelper(QuoteHandle rate, Natural monthsToStart, Natural monthsToEnd, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(Rate rate, Natural monthsToStart, Natural monthsToEnd, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(QuoteHandle rate, Natural monthsToStart, ext::shared_ptr< IborIndex > const & index, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(Rate rate, Natural monthsToStart, ext::shared_ptr< IborIndex > const & index, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(QuoteHandle rate, Natural immOffsetStart, Natural immOffsetEnd, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(Rate rate, Natural immOffsetStart, Natural immOffsetEnd, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(Rate rate, Period periodToStart, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		"FraRateHelper(QuoteHandle rate, Period periodToStart, ext::shared_ptr< IborIndex > const & iborIndex, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool useIndexedCoupon=True)\n"
		""},
	 { "delete_FraRateHelper", _wrap_delete_FraRateHelper, METH_O, "delete_FraRateHelper(FraRateHelper self)"},
	 { "FraRateHelper_swigregister", FraRateHelper_swigregister, METH_O, NULL},
	 { "FraRateHelper_swiginit", FraRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FuturesRateHelper", _wrap_new_FuturesRateHelper, METH_VARARGS, "\n"
		"FuturesRateHelper(QuoteHandle price, Date iborStartDate, Natural nMonths, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, QuoteHandle convexityAdjustment=Handle< Quote >(), Futures::Type type=IMM)\n"
		"FuturesRateHelper(Real price, Date iborStartDate, Natural nMonths, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, DayCounter dayCounter, Rate convexityAdjustment=0.0, Futures::Type type=IMM)\n"
		"FuturesRateHelper(QuoteHandle price, Date iborStartDate, Date iborEndDate, DayCounter dayCounter, QuoteHandle convexityAdjustment=Handle< Quote >(), Futures::Type type=IMM)\n"
		"FuturesRateHelper(Real price, Date iborStartDate, Date iborEndDate, DayCounter dayCounter, Rate convexityAdjustment=0.0, Futures::Type type=IMM)\n"
		"FuturesRateHelper(QuoteHandle price, Date iborStartDate, ext::shared_ptr< IborIndex > const & index, QuoteHandle convexityAdjustment=Handle< Quote >(), Futures::Type type=IMM)\n"
		"FuturesRateHelper(Real price, Date iborStartDate, ext::shared_ptr< IborIndex > const & index, Real convexityAdjustment=0.0, Futures::Type type=IMM)\n"
		""},
	 { "delete_FuturesRateHelper", _wrap_delete_FuturesRateHelper, METH_O, "delete_FuturesRateHelper(FuturesRateHelper self)"},
	 { "FuturesRateHelper_swigregister", FuturesRateHelper_swigregister, METH_O, NULL},
	 { "FuturesRateHelper_swiginit", FuturesRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_SwapRateHelper", _wrap_new_SwapRateHelper, METH_VARARGS, "\n"
		"SwapRateHelper(QuoteHandle rate, Period tenor, Calendar calendar, Frequency fixedFrequency, BusinessDayConvention fixedConvention, DayCounter fixedDayCount, ext::shared_ptr< IborIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve={}, Natural settlementDays=Null< Natural >(), Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, ext::optional< bool > withIndexedCoupons=ext::nullopt)\n"
		"SwapRateHelper(Rate rate, Period tenor, Calendar calendar, Frequency fixedFrequency, BusinessDayConvention fixedConvention, DayCounter fixedDayCount, ext::shared_ptr< IborIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve={}, Natural settlementDays=Null< Natural >(), Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, ext::optional< bool > withIndexedCoupons=ext::nullopt)\n"
		"SwapRateHelper(QuoteHandle rate, ext::shared_ptr< SwapIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve={}, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, ext::optional< bool > withIndexedCoupons=ext::nullopt)\n"
		"SwapRateHelper(Rate rate, ext::shared_ptr< SwapIndex > const & index, QuoteHandle spread=Handle< Quote >(), Period fwdStart=0*Days, YieldTermStructureHandle discountingCurve={}, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), bool endOfMonth=False, ext::optional< bool > withIndexedCoupons=ext::nullopt)\n"
		""},
	 { "SwapRateHelper_spread", _wrap_SwapRateHelper_spread, METH_O, "SwapRateHelper_spread(SwapRateHelper self) -> Spread"},
	 { "SwapRateHelper_swap", _wrap_SwapRateHelper_swap, METH_O, "SwapRateHelper_swap(SwapRateHelper self) -> ext::shared_ptr< VanillaSwap >"},
	 { "delete_SwapRateHelper", _wrap_delete_SwapRateHelper, METH_O, "delete_SwapRateHelper(SwapRateHelper self)"},
	 { "SwapRateHelper_swigregister", SwapRateHelper_swigregister, METH_O, NULL},
	 { "SwapRateHelper_swiginit", SwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_BondHelper", _wrap_new_BondHelper, METH_VARARGS, "BondHelper(QuoteHandle cleanPrice, ext::shared_ptr< Bond > const & bond, BondPrice::Type priceType=Clean)"},
	 { "BondHelper_bond", _wrap_BondHelper_bond, METH_O, "BondHelper_bond(BondHelper self) -> ext::shared_ptr< Bond >"},
	 { "delete_BondHelper", _wrap_delete_BondHelper, METH_O, "delete_BondHelper(BondHelper self)"},
	 { "BondHelper_swigregister", BondHelper_swigregister, METH_O, NULL},
	 { "BondHelper_swiginit", BondHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FixedRateBondHelper", _wrap_new_FixedRateBondHelper, METH_VARARGS, "FixedRateBondHelper(QuoteHandle cleanPrice, Size settlementDays, Real faceAmount, Schedule schedule, DoubleVector coupons, DayCounter paymentDayCounter, BusinessDayConvention paymentConvention=Following, Real redemption=100.0, Date issueDate=Date(), Calendar paymentCalendar=Calendar(), Period exCouponPeriod=Period(), Calendar exCouponCalendar=Calendar(), BusinessDayConvention exCouponConvention=Unadjusted, bool exCouponEndOfMonth=False, BondPrice::Type priceType=Clean)"},
	 { "FixedRateBondHelper_fixedRateBond", _wrap_FixedRateBondHelper_fixedRateBond, METH_O, "FixedRateBondHelper_fixedRateBond(FixedRateBondHelper self) -> ext::shared_ptr< FixedRateBond >"},
	 { "delete_FixedRateBondHelper", _wrap_delete_FixedRateBondHelper, METH_O, "delete_FixedRateBondHelper(FixedRateBondHelper self)"},
	 { "FixedRateBondHelper_swigregister", FixedRateBondHelper_swigregister, METH_O, NULL},
	 { "FixedRateBondHelper_swiginit", FixedRateBondHelper_swiginit, METH_VARARGS, NULL},
	 { "new_OISRateHelper", (PyCFunction)(void(*)(void))_wrap_new_OISRateHelper, METH_VARARGS|METH_KEYWORDS, "new_OISRateHelper(Natural settlementDays, Period tenor, QuoteHandle rate, ext::shared_ptr< OvernightIndex > const & index, YieldTermStructureHandle discountingCurve={}, bool telescopicValueDates=False, Integer paymentLag=0, BusinessDayConvention paymentConvention=Following, Frequency paymentFrequency=Annual, Calendar paymentCalendar=Calendar(), Period forwardStart=0*Days, Spread const overnightSpread=0.0, Pillar::Choice pillar=LastRelevantDate, Date customPillarDate=Date(), RateAveraging::Type averagingMethod=Compound, ext::optional< bool > endOfMonth=ext::nullopt, ext::optional< Frequency > fixedPaymentFrequency=ext::nullopt, Calendar fixedCalendar=Calendar()) -> OISRateHelper"},
	 { "OISRateHelper_swap", _wrap_OISRateHelper_swap, METH_O, "OISRateHelper_swap(OISRateHelper self) -> ext::shared_ptr< OvernightIndexedSwap >"},
	 { "delete_OISRateHelper", _wrap_delete_OISRateHelper, METH_O, "delete_OISRateHelper(OISRateHelper self)"},
	 { "OISRateHelper_swigregister", OISRateHelper_swigregister, METH_O, NULL},
	 { "OISRateHelper_swiginit", OISRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_DatedOISRateHelper", (PyCFunction)(void(*)(void))_wrap_new_DatedOISRateHelper, METH_VARARGS|METH_KEYWORDS, "new_DatedOISRateHelper(Date startDate, Date endDate, QuoteHandle rate, ext::shared_ptr< OvernightIndex > const & index, YieldTermStructureHandle discountingCurve={}, bool telescopicValueDates=False, RateAveraging::Type averagingMethod=Compound, Integer paymentLag=0, BusinessDayConvention paymentConvention=Following, Frequency paymentFrequency=Annual, Calendar paymentCalendar=Calendar(), Period forwardStart=0*Days, Spread overnightSpread=0.0, ext::optional< bool > endOfMonth=ext::nullopt, ext::optional< Frequency > fixedPaymentFrequency=ext::nullopt, Calendar fixedCalendar=Calendar()) -> DatedOISRateHelper"},
	 { "delete_DatedOISRateHelper", _wrap_delete_DatedOISRateHelper, METH_O, "delete_DatedOISRateHelper(DatedOISRateHelper self)"},
	 { "DatedOISRateHelper_swigregister", DatedOISRateHelper_swigregister, METH_O, NULL},
	 { "DatedOISRateHelper_swiginit", DatedOISRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_FxSwapRateHelper", _wrap_new_FxSwapRateHelper, METH_VARARGS, "FxSwapRateHelper(QuoteHandle fwdPoint, QuoteHandle spotFx, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, bool isFxBaseCurrencyCollateralCurrency, YieldTermStructureHandle collateralCurve, Calendar tradingCalendar=Calendar())"},
	 { "delete_FxSwapRateHelper", _wrap_delete_FxSwapRateHelper, METH_O, "delete_FxSwapRateHelper(FxSwapRateHelper self)"},
	 { "FxSwapRateHelper_swigregister", FxSwapRateHelper_swigregister, METH_O, NULL},
	 { "FxSwapRateHelper_swiginit", FxSwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIndexFutureRateHelper", _wrap_new_OvernightIndexFutureRateHelper, METH_VARARGS, "OvernightIndexFutureRateHelper(QuoteHandle price, Date valueDate, Date maturityDate, ext::shared_ptr< OvernightIndex > const & index, QuoteHandle convexityAdjustment=Handle< Quote >(), RateAveraging::Type averagingMethod=Compound)"},
	 { "delete_OvernightIndexFutureRateHelper", _wrap_delete_OvernightIndexFutureRateHelper, METH_O, "delete_OvernightIndexFutureRateHelper(OvernightIndexFutureRateHelper self)"},
	 { "OvernightIndexFutureRateHelper_swigregister", OvernightIndexFutureRateHelper_swigregister, METH_O, NULL},
	 { "OvernightIndexFutureRateHelper_swiginit", OvernightIndexFutureRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_SofrFutureRateHelper", _wrap_new_SofrFutureRateHelper, METH_VARARGS, "\n"
		"SofrFutureRateHelper(QuoteHandle price, Month referenceMonth, Year referenceYear, Frequency referenceFreq, QuoteHandle convexityAdjustment=Handle< Quote >())\n"
		"SofrFutureRateHelper(Real price, Month referenceMonth, Year referenceYear, Frequency referenceFreq, Real convexityAdjustment=0.0)\n"
		""},
	 { "delete_SofrFutureRateHelper", _wrap_delete_SofrFutureRateHelper, METH_O, "delete_SofrFutureRateHelper(SofrFutureRateHelper self)"},
	 { "SofrFutureRateHelper_swigregister", SofrFutureRateHelper_swigregister, METH_O, NULL},
	 { "SofrFutureRateHelper_swiginit", SofrFutureRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_ConstNotionalCrossCurrencyBasisSwapRateHelper", _wrap_new_ConstNotionalCrossCurrencyBasisSwapRateHelper, METH_VARARGS, "new_ConstNotionalCrossCurrencyBasisSwapRateHelper(QuoteHandle basis, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< IborIndex > baseCurrencyIndex, ext::shared_ptr< IborIndex > quoteCurrencyIndex, YieldTermStructureHandle collateralCurve, bool isFxBaseCurrencyCollateralCurrency, bool isBasisOnFxBaseCurrencyLeg) -> ConstNotionalCrossCurrencyBasisSwapRateHelper"},
	 { "delete_ConstNotionalCrossCurrencyBasisSwapRateHelper", _wrap_delete_ConstNotionalCrossCurrencyBasisSwapRateHelper, METH_O, "delete_ConstNotionalCrossCurrencyBasisSwapRateHelper(ConstNotionalCrossCurrencyBasisSwapRateHelper self)"},
	 { "ConstNotionalCrossCurrencyBasisSwapRateHelper_swigregister", ConstNotionalCrossCurrencyBasisSwapRateHelper_swigregister, METH_O, NULL},
	 { "ConstNotionalCrossCurrencyBasisSwapRateHelper_swiginit", ConstNotionalCrossCurrencyBasisSwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_MtMCrossCurrencyBasisSwapRateHelper", _wrap_new_MtMCrossCurrencyBasisSwapRateHelper, METH_VARARGS, "new_MtMCrossCurrencyBasisSwapRateHelper(QuoteHandle basis, Period tenor, Natural fixingDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< IborIndex > baseCurrencyIndex, ext::shared_ptr< IborIndex > quoteCurrencyIndex, YieldTermStructureHandle collateralCurve, bool isFxBaseCurrencyCollateralCurrency, bool isBasisOnFxBaseCurrencyLeg, bool isFxBaseCurrencyLegResettable) -> MtMCrossCurrencyBasisSwapRateHelper"},
	 { "delete_MtMCrossCurrencyBasisSwapRateHelper", _wrap_delete_MtMCrossCurrencyBasisSwapRateHelper, METH_O, "delete_MtMCrossCurrencyBasisSwapRateHelper(MtMCrossCurrencyBasisSwapRateHelper self)"},
	 { "MtMCrossCurrencyBasisSwapRateHelper_swigregister", MtMCrossCurrencyBasisSwapRateHelper_swigregister, METH_O, NULL},
	 { "MtMCrossCurrencyBasisSwapRateHelper_swiginit", MtMCrossCurrencyBasisSwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_IborIborBasisSwapRateHelper", _wrap_new_IborIborBasisSwapRateHelper, METH_VARARGS, "new_IborIborBasisSwapRateHelper(QuoteHandle basis, Period tenor, Natural settlementDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< IborIndex > const & baseIndex, ext::shared_ptr< IborIndex > const & otherIndex, YieldTermStructureHandle discountHandle, bool bootstrapBaseCurve) -> IborIborBasisSwapRateHelper"},
	 { "delete_IborIborBasisSwapRateHelper", _wrap_delete_IborIborBasisSwapRateHelper, METH_O, "delete_IborIborBasisSwapRateHelper(IborIborBasisSwapRateHelper self)"},
	 { "IborIborBasisSwapRateHelper_swigregister", IborIborBasisSwapRateHelper_swigregister, METH_O, NULL},
	 { "IborIborBasisSwapRateHelper_swiginit", IborIborBasisSwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_OvernightIborBasisSwapRateHelper", _wrap_new_OvernightIborBasisSwapRateHelper, METH_VARARGS, "OvernightIborBasisSwapRateHelper(QuoteHandle basis, Period tenor, Natural settlementDays, Calendar calendar, BusinessDayConvention convention, bool endOfMonth, ext::shared_ptr< OvernightIndex > const & baseIndex, ext::shared_ptr< IborIndex > const & otherIndex, YieldTermStructureHandle discountHandle=Handle< YieldTermStructure >())"},
	 { "delete_OvernightIborBasisSwapRateHelper", _wrap_delete_OvernightIborBasisSwapRateHelper, METH_O, "delete_OvernightIborBasisSwapRateHelper(OvernightIborBasisSwapRateHelper self)"},
	 { "OvernightIborBasisSwapRateHelper_swigregister", OvernightIborBasisSwapRateHelper_swigregister, METH_O, NULL},
	 { "OvernightIborBasisSwapRateHelper_swiginit", OvernightIborBasisSwapRateHelper_swiginit, METH_VARARGS, NULL},
	 { "new_ArithmeticOISRateHelper", _wrap_new_ArithmeticOISRateHelper, METH_VARARGS, "ArithmeticOISRateHelper(Natural settlementDays, Period tenor, Frequency fixedLegPaymentFrequency, QuoteHandle fixedRate, ext::shared_ptr< OvernightIndex > overnightIndex, Frequency overnightLegPaymentFrequency, QuoteHandle spread, Real meanReversionSpeed=0.03, Real volatility=0.00, bool byApprox=False, YieldTermStructureHandle discountingCurve=Handle< YieldTermStructure >())"},
	 { "ArithmeticOISRateHelper_swap", _wrap_ArithmeticOISRateHelper_swap, METH_O, "ArithmeticOISRateHelper_swap(ArithmeticOISRateHelper self) -> ext::shared_ptr< ArithmeticAverageOIS >"},
	 { "delete_ArithmeticOISRateHelper", _wrap_delete_ArithmeticOISRateHelper, METH_O, "delete_ArithmeticOISRateHelper(ArithmeticOISRateHelper self)"},
	 { "ArithmeticOISRateHelper_swigregister", ArithmeticOISRateHelper_swigregister, METH_O, NULL},
	 { "ArithmeticOISRateHelper_swiginit", ArithmeticOISRateHelper_swiginit, METH_VARARGS, NULL},
	 { "RateHelperVector_iterator", _wrap_RateHelperVector_iterator, METH_O, "RateHelperVector_iterator(RateHelperVector self) -> SwigPyIterator"},
	 { "RateHelperVector___nonzero__", _wrap_RateHelperVector___nonzero__, METH_O, "RateHelperVector___nonzero__(RateHelperVector self) -> bool"},
	 { "RateHelperVector___bool__", _wrap_RateHelperVector___bool__, METH_O, "RateHelperVector___bool__(RateHelperVector self) -> bool"},
	 { "RateHelperVector___len__", _wrap_RateHelperVector___len__, METH_O, "RateHelperVector___len__(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::size_type"},
	 { "RateHelperVector___getslice__", _wrap_RateHelperVector___getslice__, METH_VARARGS, "RateHelperVector___getslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j) -> RateHelperVector"},
	 { "RateHelperVector___setslice__", _wrap_RateHelperVector___setslice__, METH_VARARGS, "\n"
		"RateHelperVector___setslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j)\n"
		"RateHelperVector___setslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j, RateHelperVector v)\n"
		""},
	 { "RateHelperVector___delslice__", _wrap_RateHelperVector___delslice__, METH_VARARGS, "RateHelperVector___delslice__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::difference_type j)"},
	 { "RateHelperVector___delitem__", _wrap_RateHelperVector___delitem__, METH_VARARGS, "\n"
		"RateHelperVector___delitem__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i)\n"
		"RateHelperVector___delitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "RateHelperVector___getitem__", _wrap_RateHelperVector___getitem__, METH_VARARGS, "\n"
		"RateHelperVector___getitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice) -> RateHelperVector\n"
		"RateHelperVector___getitem__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i) -> std::vector< ext::shared_ptr< RateHelper > >::value_type const &\n"
		""},
	 { "RateHelperVector___setitem__", _wrap_RateHelperVector___setitem__, METH_VARARGS, "\n"
		"RateHelperVector___setitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice, RateHelperVector v)\n"
		"RateHelperVector___setitem__(RateHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"RateHelperVector___setitem__(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::difference_type i, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)\n"
		""},
	 { "RateHelperVector_pop", _wrap_RateHelperVector_pop, METH_O, "RateHelperVector_pop(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::value_type"},
	 { "RateHelperVector_append", _wrap_RateHelperVector_append, METH_VARARGS, "RateHelperVector_append(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)"},
	 { "RateHelperVector_empty", _wrap_RateHelperVector_empty, METH_O, "RateHelperVector_empty(RateHelperVector self) -> bool"},
	 { "RateHelperVector_size", _wrap_RateHelperVector_size, METH_O, "RateHelperVector_size(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::size_type"},
	 { "RateHelperVector_swap", _wrap_RateHelperVector_swap, METH_VARARGS, "RateHelperVector_swap(RateHelperVector self, RateHelperVector v)"},
	 { "RateHelperVector_begin", _wrap_RateHelperVector_begin, METH_O, "RateHelperVector_begin(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::iterator"},
	 { "RateHelperVector_end", _wrap_RateHelperVector_end, METH_O, "RateHelperVector_end(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::iterator"},
	 { "RateHelperVector_rbegin", _wrap_RateHelperVector_rbegin, METH_O, "RateHelperVector_rbegin(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator"},
	 { "RateHelperVector_rend", _wrap_RateHelperVector_rend, METH_O, "RateHelperVector_rend(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::reverse_iterator"},
	 { "RateHelperVector_clear", _wrap_RateHelperVector_clear, METH_O, "RateHelperVector_clear(RateHelperVector self)"},
	 { "RateHelperVector_get_allocator", _wrap_RateHelperVector_get_allocator, METH_O, "RateHelperVector_get_allocator(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::allocator_type"},
	 { "RateHelperVector_pop_back", _wrap_RateHelperVector_pop_back, METH_O, "RateHelperVector_pop_back(RateHelperVector self)"},
	 { "RateHelperVector_erase", _wrap_RateHelperVector_erase, METH_VARARGS, "\n"
		"RateHelperVector_erase(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator pos) -> std::vector< ext::shared_ptr< RateHelper > >::iterator\n"
		"RateHelperVector_erase(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator first, std::vector< ext::shared_ptr< RateHelper > >::iterator last) -> std::vector< ext::shared_ptr< RateHelper > >::iterator\n"
		""},
	 { "new_RateHelperVector", _wrap_new_RateHelperVector, METH_VARARGS, "\n"
		"RateHelperVector()\n"
		"RateHelperVector(RateHelperVector other)\n"
		"RateHelperVector(std::vector< ext::shared_ptr< RateHelper > >::size_type size)\n"
		"new_RateHelperVector(std::vector< ext::shared_ptr< RateHelper > >::size_type size, std::vector< ext::shared_ptr< RateHelper > >::value_type const & value) -> RateHelperVector\n"
		""},
	 { "RateHelperVector_push_back", _wrap_RateHelperVector_push_back, METH_VARARGS, "RateHelperVector_push_back(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)"},
	 { "RateHelperVector_front", _wrap_RateHelperVector_front, METH_O, "RateHelperVector_front(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::value_type const &"},
	 { "RateHelperVector_back", _wrap_RateHelperVector_back, METH_O, "RateHelperVector_back(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::value_type const &"},
	 { "RateHelperVector_assign", _wrap_RateHelperVector_assign, METH_VARARGS, "RateHelperVector_assign(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type n, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)"},
	 { "RateHelperVector_resize", _wrap_RateHelperVector_resize, METH_VARARGS, "\n"
		"RateHelperVector_resize(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type new_size)\n"
		"RateHelperVector_resize(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type new_size, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)\n"
		""},
	 { "RateHelperVector_insert", _wrap_RateHelperVector_insert, METH_VARARGS, "\n"
		"RateHelperVector_insert(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator pos, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< RateHelper > >::iterator\n"
		"RateHelperVector_insert(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::iterator pos, std::vector< ext::shared_ptr< RateHelper > >::size_type n, std::vector< ext::shared_ptr< RateHelper > >::value_type const & x)\n"
		""},
	 { "RateHelperVector_reserve", _wrap_RateHelperVector_reserve, METH_VARARGS, "RateHelperVector_reserve(RateHelperVector self, std::vector< ext::shared_ptr< RateHelper > >::size_type n)"},
	 { "RateHelperVector_capacity", _wrap_RateHelperVector_capacity, METH_O, "RateHelperVector_capacity(RateHelperVector self) -> std::vector< ext::shared_ptr< RateHelper > >::size_type"},
	 { "delete_RateHelperVector", _wrap_delete_RateHelperVector, METH_O, "delete_RateHelperVector(RateHelperVector self)"},
	 { "RateHelperVector_swigregister", RateHelperVector_swigregister, METH_O, NULL},
	 { "RateHelperVector_swiginit", RateHelperVector_swiginit, METH_VARARGS, NULL},
	 { "BondHelperVector_iterator", _wrap_BondHelperVector_iterator, METH_O, "BondHelperVector_iterator(BondHelperVector self) -> SwigPyIterator"},
	 { "BondHelperVector___nonzero__", _wrap_BondHelperVector___nonzero__, METH_O, "BondHelperVector___nonzero__(BondHelperVector self) -> bool"},
	 { "BondHelperVector___bool__", _wrap_BondHelperVector___bool__, METH_O, "BondHelperVector___bool__(BondHelperVector self) -> bool"},
	 { "BondHelperVector___len__", _wrap_BondHelperVector___len__, METH_O, "BondHelperVector___len__(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::size_type"},
	 { "BondHelperVector___getslice__", _wrap_BondHelperVector___getslice__, METH_VARARGS, "BondHelperVector___getslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j) -> BondHelperVector"},
	 { "BondHelperVector___setslice__", _wrap_BondHelperVector___setslice__, METH_VARARGS, "\n"
		"BondHelperVector___setslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j)\n"
		"BondHelperVector___setslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j, BondHelperVector v)\n"
		""},
	 { "BondHelperVector___delslice__", _wrap_BondHelperVector___delslice__, METH_VARARGS, "BondHelperVector___delslice__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::difference_type j)"},
	 { "BondHelperVector___delitem__", _wrap_BondHelperVector___delitem__, METH_VARARGS, "\n"
		"BondHelperVector___delitem__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i)\n"
		"BondHelperVector___delitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "BondHelperVector___getitem__", _wrap_BondHelperVector___getitem__, METH_VARARGS, "\n"
		"BondHelperVector___getitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice) -> BondHelperVector\n"
		"BondHelperVector___getitem__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i) -> std::vector< ext::shared_ptr< BondHelper > >::value_type const &\n"
		""},
	 { "BondHelperVector___setitem__", _wrap_BondHelperVector___setitem__, METH_VARARGS, "\n"
		"BondHelperVector___setitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice, BondHelperVector v)\n"
		"BondHelperVector___setitem__(BondHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"BondHelperVector___setitem__(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::difference_type i, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)\n"
		""},
	 { "BondHelperVector_pop", _wrap_BondHelperVector_pop, METH_O, "BondHelperVector_pop(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::value_type"},
	 { "BondHelperVector_append", _wrap_BondHelperVector_append, METH_VARARGS, "BondHelperVector_append(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)"},
	 { "BondHelperVector_empty", _wrap_BondHelperVector_empty, METH_O, "BondHelperVector_empty(BondHelperVector self) -> bool"},
	 { "BondHelperVector_size", _wrap_BondHelperVector_size, METH_O, "BondHelperVector_size(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::size_type"},
	 { "BondHelperVector_swap", _wrap_BondHelperVector_swap, METH_VARARGS, "BondHelperVector_swap(BondHelperVector self, BondHelperVector v)"},
	 { "BondHelperVector_begin", _wrap_BondHelperVector_begin, METH_O, "BondHelperVector_begin(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::iterator"},
	 { "BondHelperVector_end", _wrap_BondHelperVector_end, METH_O, "BondHelperVector_end(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::iterator"},
	 { "BondHelperVector_rbegin", _wrap_BondHelperVector_rbegin, METH_O, "BondHelperVector_rbegin(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator"},
	 { "BondHelperVector_rend", _wrap_BondHelperVector_rend, METH_O, "BondHelperVector_rend(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::reverse_iterator"},
	 { "BondHelperVector_clear", _wrap_BondHelperVector_clear, METH_O, "BondHelperVector_clear(BondHelperVector self)"},
	 { "BondHelperVector_get_allocator", _wrap_BondHelperVector_get_allocator, METH_O, "BondHelperVector_get_allocator(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::allocator_type"},
	 { "BondHelperVector_pop_back", _wrap_BondHelperVector_pop_back, METH_O, "BondHelperVector_pop_back(BondHelperVector self)"},
	 { "BondHelperVector_erase", _wrap_BondHelperVector_erase, METH_VARARGS, "\n"
		"BondHelperVector_erase(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator pos) -> std::vector< ext::shared_ptr< BondHelper > >::iterator\n"
		"BondHelperVector_erase(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator first, std::vector< ext::shared_ptr< BondHelper > >::iterator last) -> std::vector< ext::shared_ptr< BondHelper > >::iterator\n"
		""},
	 { "new_BondHelperVector", _wrap_new_BondHelperVector, METH_VARARGS, "\n"
		"BondHelperVector()\n"
		"BondHelperVector(BondHelperVector other)\n"
		"BondHelperVector(std::vector< ext::shared_ptr< BondHelper > >::size_type size)\n"
		"new_BondHelperVector(std::vector< ext::shared_ptr< BondHelper > >::size_type size, std::vector< ext::shared_ptr< BondHelper > >::value_type const & value) -> BondHelperVector\n"
		""},
	 { "BondHelperVector_push_back", _wrap_BondHelperVector_push_back, METH_VARARGS, "BondHelperVector_push_back(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)"},
	 { "BondHelperVector_front", _wrap_BondHelperVector_front, METH_O, "BondHelperVector_front(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::value_type const &"},
	 { "BondHelperVector_back", _wrap_BondHelperVector_back, METH_O, "BondHelperVector_back(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::value_type const &"},
	 { "BondHelperVector_assign", _wrap_BondHelperVector_assign, METH_VARARGS, "BondHelperVector_assign(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type n, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)"},
	 { "BondHelperVector_resize", _wrap_BondHelperVector_resize, METH_VARARGS, "\n"
		"BondHelperVector_resize(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type new_size)\n"
		"BondHelperVector_resize(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type new_size, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)\n"
		""},
	 { "BondHelperVector_insert", _wrap_BondHelperVector_insert, METH_VARARGS, "\n"
		"BondHelperVector_insert(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator pos, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< BondHelper > >::iterator\n"
		"BondHelperVector_insert(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::iterator pos, std::vector< ext::shared_ptr< BondHelper > >::size_type n, std::vector< ext::shared_ptr< BondHelper > >::value_type const & x)\n"
		""},
	 { "BondHelperVector_reserve", _wrap_BondHelperVector_reserve, METH_VARARGS, "BondHelperVector_reserve(BondHelperVector self, std::vector< ext::shared_ptr< BondHelper > >::size_type n)"},
	 { "BondHelperVector_capacity", _wrap_BondHelperVector_capacity, METH_O, "BondHelperVector_capacity(BondHelperVector self) -> std::vector< ext::shared_ptr< BondHelper > >::size_type"},
	 { "delete_BondHelperVector", _wrap_delete_BondHelperVector, METH_O, "delete_BondHelperVector(BondHelperVector self)"},
	 { "BondHelperVector_swigregister", BondHelperVector_swigregister, METH_O, NULL},
	 { "BondHelperVector_swiginit", BondHelperVector_swiginit, METH_VARARGS, NULL},
	 { "as_depositratehelper", _wrap_as_depositratehelper, METH_O, "as_depositratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< DepositRateHelper > const"},
	 { "as_fraratehelper", _wrap_as_fraratehelper, METH_O, "as_fraratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< FraRateHelper > const"},
	 { "as_swapratehelper", _wrap_as_swapratehelper, METH_O, "as_swapratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< SwapRateHelper > const"},
	 { "as_oisratehelper", _wrap_as_oisratehelper, METH_O, "as_oisratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< OISRateHelper > const"},
	 { "as_constnotionalcrosscurrencybasisswapratehelper", _wrap_as_constnotionalcrosscurrencybasisswapratehelper, METH_O, "as_constnotionalcrosscurrencybasisswapratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > const"},
	 { "as_mtmcrosscurrencybasisswapratehelper", _wrap_as_mtmcrosscurrencybasisswapratehelper, METH_O, "as_mtmcrosscurrencybasisswapratehelper(ext::shared_ptr< RateHelper > const helper) -> ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > const"},
	 { "new_Discount", _wrap_new_Discount, METH_NOARGS, "new_Discount() -> Discount"},
	 { "delete_Discount", _wrap_delete_Discount, METH_O, "delete_Discount(Discount self)"},
	 { "Discount_swigregister", Discount_swigregister, METH_O, NULL},
	 { "Discount_swiginit", Discount_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroYield", _wrap_new_ZeroYield, METH_NOARGS, "new_ZeroYield() -> ZeroYield"},
	 { "delete_ZeroYield", _wrap_delete_ZeroYield, METH_O, "delete_ZeroYield(ZeroYield self)"},
	 { "ZeroYield_swigregister", ZeroYield_swigregister, METH_O, NULL},
	 { "ZeroYield_swiginit", ZeroYield_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardRate", _wrap_new_ForwardRate, METH_NOARGS, "new_ForwardRate() -> ForwardRate"},
	 { "delete_ForwardRate", _wrap_delete_ForwardRate, METH_O, "delete_ForwardRate(ForwardRate self)"},
	 { "ForwardRate_swigregister", ForwardRate_swigregister, METH_O, NULL},
	 { "ForwardRate_swiginit", ForwardRate_swiginit, METH_VARARGS, NULL},
	 { "new_IterativeBootstrap", (PyCFunction)(void(*)(void))_wrap_new_IterativeBootstrap, METH_VARARGS|METH_KEYWORDS, "new_IterativeBootstrap(doubleOrNull accuracy=Null< double >(), doubleOrNull minValue=Null< double >(), doubleOrNull maxValue=Null< double >(), Size maxAttempts=1, Real maxFactor=2.0, Real minFactor=2.0, bool dontThrow=False, Size dontThrowSteps=10, Size maxEvaluations=100) -> IterativeBootstrap"},
	 { "delete_IterativeBootstrap", _wrap_delete_IterativeBootstrap, METH_O, "delete_IterativeBootstrap(IterativeBootstrap self)"},
	 { "IterativeBootstrap_swigregister", IterativeBootstrap_swigregister, METH_O, NULL},
	 { "IterativeBootstrap_swiginit", IterativeBootstrap_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseFlatForward", _wrap_new_PiecewiseFlatForward, METH_VARARGS, "\n"
		"PiecewiseFlatForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseFlatForward(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseFlatForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, BackwardFlat i=BackwardFlat())\n"
		"PiecewiseFlatForward(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, BackwardFlat i=BackwardFlat())\n"
		""},
	 { "PiecewiseFlatForward_dates", _wrap_PiecewiseFlatForward_dates, METH_O, "PiecewiseFlatForward_dates(PiecewiseFlatForward self) -> DateVector"},
	 { "PiecewiseFlatForward_times", _wrap_PiecewiseFlatForward_times, METH_O, "PiecewiseFlatForward_times(PiecewiseFlatForward self) -> DoubleVector"},
	 { "PiecewiseFlatForward_nodes", _wrap_PiecewiseFlatForward_nodes, METH_O, "PiecewiseFlatForward_nodes(PiecewiseFlatForward self) -> NodeVector"},
	 { "PiecewiseFlatForward_recalculate", _wrap_PiecewiseFlatForward_recalculate, METH_O, "PiecewiseFlatForward_recalculate(PiecewiseFlatForward self)"},
	 { "PiecewiseFlatForward_freeze", _wrap_PiecewiseFlatForward_freeze, METH_O, "PiecewiseFlatForward_freeze(PiecewiseFlatForward self)"},
	 { "PiecewiseFlatForward_unfreeze", _wrap_PiecewiseFlatForward_unfreeze, METH_O, "PiecewiseFlatForward_unfreeze(PiecewiseFlatForward self)"},
	 { "delete_PiecewiseFlatForward", _wrap_delete_PiecewiseFlatForward, METH_O, "delete_PiecewiseFlatForward(PiecewiseFlatForward self)"},
	 { "PiecewiseFlatForward_swigregister", PiecewiseFlatForward_swigregister, METH_O, NULL},
	 { "PiecewiseFlatForward_swiginit", PiecewiseFlatForward_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLogLinearDiscount", _wrap_new_PiecewiseLogLinearDiscount, METH_VARARGS, "\n"
		"PiecewiseLogLinearDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), LogLinear i=LogLinear(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLogLinearDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), LogLinear i=LogLinear(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLogLinearDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, LogLinear i=LogLinear())\n"
		"PiecewiseLogLinearDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, LogLinear i=LogLinear())\n"
		""},
	 { "PiecewiseLogLinearDiscount_dates", _wrap_PiecewiseLogLinearDiscount_dates, METH_O, "PiecewiseLogLinearDiscount_dates(PiecewiseLogLinearDiscount self) -> DateVector"},
	 { "PiecewiseLogLinearDiscount_times", _wrap_PiecewiseLogLinearDiscount_times, METH_O, "PiecewiseLogLinearDiscount_times(PiecewiseLogLinearDiscount self) -> DoubleVector"},
	 { "PiecewiseLogLinearDiscount_nodes", _wrap_PiecewiseLogLinearDiscount_nodes, METH_O, "PiecewiseLogLinearDiscount_nodes(PiecewiseLogLinearDiscount self) -> NodeVector"},
	 { "PiecewiseLogLinearDiscount_recalculate", _wrap_PiecewiseLogLinearDiscount_recalculate, METH_O, "PiecewiseLogLinearDiscount_recalculate(PiecewiseLogLinearDiscount self)"},
	 { "PiecewiseLogLinearDiscount_freeze", _wrap_PiecewiseLogLinearDiscount_freeze, METH_O, "PiecewiseLogLinearDiscount_freeze(PiecewiseLogLinearDiscount self)"},
	 { "PiecewiseLogLinearDiscount_unfreeze", _wrap_PiecewiseLogLinearDiscount_unfreeze, METH_O, "PiecewiseLogLinearDiscount_unfreeze(PiecewiseLogLinearDiscount self)"},
	 { "delete_PiecewiseLogLinearDiscount", _wrap_delete_PiecewiseLogLinearDiscount, METH_O, "delete_PiecewiseLogLinearDiscount(PiecewiseLogLinearDiscount self)"},
	 { "PiecewiseLogLinearDiscount_swigregister", PiecewiseLogLinearDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseLogLinearDiscount_swiginit", PiecewiseLogLinearDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLinearForward", _wrap_new_PiecewiseLinearForward, METH_VARARGS, "\n"
		"PiecewiseLinearForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLinearForward(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLinearForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Linear i=Linear())\n"
		"PiecewiseLinearForward(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Linear i=Linear())\n"
		""},
	 { "PiecewiseLinearForward_dates", _wrap_PiecewiseLinearForward_dates, METH_O, "PiecewiseLinearForward_dates(PiecewiseLinearForward self) -> DateVector"},
	 { "PiecewiseLinearForward_times", _wrap_PiecewiseLinearForward_times, METH_O, "PiecewiseLinearForward_times(PiecewiseLinearForward self) -> DoubleVector"},
	 { "PiecewiseLinearForward_nodes", _wrap_PiecewiseLinearForward_nodes, METH_O, "PiecewiseLinearForward_nodes(PiecewiseLinearForward self) -> NodeVector"},
	 { "PiecewiseLinearForward_recalculate", _wrap_PiecewiseLinearForward_recalculate, METH_O, "PiecewiseLinearForward_recalculate(PiecewiseLinearForward self)"},
	 { "PiecewiseLinearForward_freeze", _wrap_PiecewiseLinearForward_freeze, METH_O, "PiecewiseLinearForward_freeze(PiecewiseLinearForward self)"},
	 { "PiecewiseLinearForward_unfreeze", _wrap_PiecewiseLinearForward_unfreeze, METH_O, "PiecewiseLinearForward_unfreeze(PiecewiseLinearForward self)"},
	 { "delete_PiecewiseLinearForward", _wrap_delete_PiecewiseLinearForward, METH_O, "delete_PiecewiseLinearForward(PiecewiseLinearForward self)"},
	 { "PiecewiseLinearForward_swigregister", PiecewiseLinearForward_swigregister, METH_O, NULL},
	 { "PiecewiseLinearForward_swiginit", PiecewiseLinearForward_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLinearZero", _wrap_new_PiecewiseLinearZero, METH_VARARGS, "\n"
		"PiecewiseLinearZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLinearZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Linear i=Linear(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLinearZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Linear i=Linear())\n"
		"PiecewiseLinearZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Linear i=Linear())\n"
		""},
	 { "PiecewiseLinearZero_dates", _wrap_PiecewiseLinearZero_dates, METH_O, "PiecewiseLinearZero_dates(PiecewiseLinearZero self) -> DateVector"},
	 { "PiecewiseLinearZero_times", _wrap_PiecewiseLinearZero_times, METH_O, "PiecewiseLinearZero_times(PiecewiseLinearZero self) -> DoubleVector"},
	 { "PiecewiseLinearZero_nodes", _wrap_PiecewiseLinearZero_nodes, METH_O, "PiecewiseLinearZero_nodes(PiecewiseLinearZero self) -> NodeVector"},
	 { "PiecewiseLinearZero_recalculate", _wrap_PiecewiseLinearZero_recalculate, METH_O, "PiecewiseLinearZero_recalculate(PiecewiseLinearZero self)"},
	 { "PiecewiseLinearZero_freeze", _wrap_PiecewiseLinearZero_freeze, METH_O, "PiecewiseLinearZero_freeze(PiecewiseLinearZero self)"},
	 { "PiecewiseLinearZero_unfreeze", _wrap_PiecewiseLinearZero_unfreeze, METH_O, "PiecewiseLinearZero_unfreeze(PiecewiseLinearZero self)"},
	 { "delete_PiecewiseLinearZero", _wrap_delete_PiecewiseLinearZero, METH_O, "delete_PiecewiseLinearZero(PiecewiseLinearZero self)"},
	 { "PiecewiseLinearZero_swigregister", PiecewiseLinearZero_swigregister, METH_O, NULL},
	 { "PiecewiseLinearZero_swiginit", PiecewiseLinearZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseCubicZero", _wrap_new_PiecewiseCubicZero, METH_VARARGS, "\n"
		"PiecewiseCubicZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Cubic i=Cubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseCubicZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Cubic i=Cubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseCubicZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Cubic i=Cubic())\n"
		"PiecewiseCubicZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Cubic i=Cubic())\n"
		""},
	 { "PiecewiseCubicZero_dates", _wrap_PiecewiseCubicZero_dates, METH_O, "PiecewiseCubicZero_dates(PiecewiseCubicZero self) -> DateVector"},
	 { "PiecewiseCubicZero_times", _wrap_PiecewiseCubicZero_times, METH_O, "PiecewiseCubicZero_times(PiecewiseCubicZero self) -> DoubleVector"},
	 { "PiecewiseCubicZero_nodes", _wrap_PiecewiseCubicZero_nodes, METH_O, "PiecewiseCubicZero_nodes(PiecewiseCubicZero self) -> NodeVector"},
	 { "PiecewiseCubicZero_recalculate", _wrap_PiecewiseCubicZero_recalculate, METH_O, "PiecewiseCubicZero_recalculate(PiecewiseCubicZero self)"},
	 { "PiecewiseCubicZero_freeze", _wrap_PiecewiseCubicZero_freeze, METH_O, "PiecewiseCubicZero_freeze(PiecewiseCubicZero self)"},
	 { "PiecewiseCubicZero_unfreeze", _wrap_PiecewiseCubicZero_unfreeze, METH_O, "PiecewiseCubicZero_unfreeze(PiecewiseCubicZero self)"},
	 { "delete_PiecewiseCubicZero", _wrap_delete_PiecewiseCubicZero, METH_O, "delete_PiecewiseCubicZero(PiecewiseCubicZero self)"},
	 { "PiecewiseCubicZero_swigregister", PiecewiseCubicZero_swigregister, METH_O, NULL},
	 { "PiecewiseCubicZero_swiginit", PiecewiseCubicZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLogCubicDiscount", _wrap_new_PiecewiseLogCubicDiscount, METH_VARARGS, "\n"
		"PiecewiseLogCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), MonotonicLogCubic i=MonotonicLogCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLogCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), MonotonicLogCubic i=MonotonicLogCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLogCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, MonotonicLogCubic i=MonotonicLogCubic())\n"
		"PiecewiseLogCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, MonotonicLogCubic i=MonotonicLogCubic())\n"
		""},
	 { "PiecewiseLogCubicDiscount_dates", _wrap_PiecewiseLogCubicDiscount_dates, METH_O, "PiecewiseLogCubicDiscount_dates(PiecewiseLogCubicDiscount self) -> DateVector"},
	 { "PiecewiseLogCubicDiscount_times", _wrap_PiecewiseLogCubicDiscount_times, METH_O, "PiecewiseLogCubicDiscount_times(PiecewiseLogCubicDiscount self) -> DoubleVector"},
	 { "PiecewiseLogCubicDiscount_nodes", _wrap_PiecewiseLogCubicDiscount_nodes, METH_O, "PiecewiseLogCubicDiscount_nodes(PiecewiseLogCubicDiscount self) -> NodeVector"},
	 { "PiecewiseLogCubicDiscount_recalculate", _wrap_PiecewiseLogCubicDiscount_recalculate, METH_O, "PiecewiseLogCubicDiscount_recalculate(PiecewiseLogCubicDiscount self)"},
	 { "PiecewiseLogCubicDiscount_freeze", _wrap_PiecewiseLogCubicDiscount_freeze, METH_O, "PiecewiseLogCubicDiscount_freeze(PiecewiseLogCubicDiscount self)"},
	 { "PiecewiseLogCubicDiscount_unfreeze", _wrap_PiecewiseLogCubicDiscount_unfreeze, METH_O, "PiecewiseLogCubicDiscount_unfreeze(PiecewiseLogCubicDiscount self)"},
	 { "delete_PiecewiseLogCubicDiscount", _wrap_delete_PiecewiseLogCubicDiscount, METH_O, "delete_PiecewiseLogCubicDiscount(PiecewiseLogCubicDiscount self)"},
	 { "PiecewiseLogCubicDiscount_swigregister", PiecewiseLogCubicDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseLogCubicDiscount_swiginit", PiecewiseLogCubicDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseSplineCubicDiscount", _wrap_new_PiecewiseSplineCubicDiscount, METH_VARARGS, "\n"
		"PiecewiseSplineCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseSplineCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseSplineCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, SplineCubic i=SplineCubic())\n"
		"PiecewiseSplineCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, SplineCubic i=SplineCubic())\n"
		""},
	 { "PiecewiseSplineCubicDiscount_dates", _wrap_PiecewiseSplineCubicDiscount_dates, METH_O, "PiecewiseSplineCubicDiscount_dates(PiecewiseSplineCubicDiscount self) -> DateVector"},
	 { "PiecewiseSplineCubicDiscount_times", _wrap_PiecewiseSplineCubicDiscount_times, METH_O, "PiecewiseSplineCubicDiscount_times(PiecewiseSplineCubicDiscount self) -> DoubleVector"},
	 { "PiecewiseSplineCubicDiscount_nodes", _wrap_PiecewiseSplineCubicDiscount_nodes, METH_O, "PiecewiseSplineCubicDiscount_nodes(PiecewiseSplineCubicDiscount self) -> NodeVector"},
	 { "PiecewiseSplineCubicDiscount_recalculate", _wrap_PiecewiseSplineCubicDiscount_recalculate, METH_O, "PiecewiseSplineCubicDiscount_recalculate(PiecewiseSplineCubicDiscount self)"},
	 { "PiecewiseSplineCubicDiscount_freeze", _wrap_PiecewiseSplineCubicDiscount_freeze, METH_O, "PiecewiseSplineCubicDiscount_freeze(PiecewiseSplineCubicDiscount self)"},
	 { "PiecewiseSplineCubicDiscount_unfreeze", _wrap_PiecewiseSplineCubicDiscount_unfreeze, METH_O, "PiecewiseSplineCubicDiscount_unfreeze(PiecewiseSplineCubicDiscount self)"},
	 { "delete_PiecewiseSplineCubicDiscount", _wrap_delete_PiecewiseSplineCubicDiscount, METH_O, "delete_PiecewiseSplineCubicDiscount(PiecewiseSplineCubicDiscount self)"},
	 { "PiecewiseSplineCubicDiscount_swigregister", PiecewiseSplineCubicDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseSplineCubicDiscount_swiginit", PiecewiseSplineCubicDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseKrugerZero", _wrap_new_PiecewiseKrugerZero, METH_VARARGS, "\n"
		"PiecewiseKrugerZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Kruger i=Kruger(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseKrugerZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), Kruger i=Kruger(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseKrugerZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Kruger i=Kruger())\n"
		"PiecewiseKrugerZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, Kruger i=Kruger())\n"
		""},
	 { "PiecewiseKrugerZero_dates", _wrap_PiecewiseKrugerZero_dates, METH_O, "PiecewiseKrugerZero_dates(PiecewiseKrugerZero self) -> DateVector"},
	 { "PiecewiseKrugerZero_times", _wrap_PiecewiseKrugerZero_times, METH_O, "PiecewiseKrugerZero_times(PiecewiseKrugerZero self) -> DoubleVector"},
	 { "PiecewiseKrugerZero_nodes", _wrap_PiecewiseKrugerZero_nodes, METH_O, "PiecewiseKrugerZero_nodes(PiecewiseKrugerZero self) -> NodeVector"},
	 { "PiecewiseKrugerZero_recalculate", _wrap_PiecewiseKrugerZero_recalculate, METH_O, "PiecewiseKrugerZero_recalculate(PiecewiseKrugerZero self)"},
	 { "PiecewiseKrugerZero_freeze", _wrap_PiecewiseKrugerZero_freeze, METH_O, "PiecewiseKrugerZero_freeze(PiecewiseKrugerZero self)"},
	 { "PiecewiseKrugerZero_unfreeze", _wrap_PiecewiseKrugerZero_unfreeze, METH_O, "PiecewiseKrugerZero_unfreeze(PiecewiseKrugerZero self)"},
	 { "delete_PiecewiseKrugerZero", _wrap_delete_PiecewiseKrugerZero, METH_O, "delete_PiecewiseKrugerZero(PiecewiseKrugerZero self)"},
	 { "PiecewiseKrugerZero_swigregister", PiecewiseKrugerZero_swigregister, METH_O, NULL},
	 { "PiecewiseKrugerZero_swiginit", PiecewiseKrugerZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseKrugerLogDiscount", _wrap_new_PiecewiseKrugerLogDiscount, METH_VARARGS, "\n"
		"PiecewiseKrugerLogDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), KrugerLog i=KrugerLog(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseKrugerLogDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), KrugerLog i=KrugerLog(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseKrugerLogDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, KrugerLog i=KrugerLog())\n"
		"PiecewiseKrugerLogDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, KrugerLog i=KrugerLog())\n"
		""},
	 { "PiecewiseKrugerLogDiscount_dates", _wrap_PiecewiseKrugerLogDiscount_dates, METH_O, "PiecewiseKrugerLogDiscount_dates(PiecewiseKrugerLogDiscount self) -> DateVector"},
	 { "PiecewiseKrugerLogDiscount_times", _wrap_PiecewiseKrugerLogDiscount_times, METH_O, "PiecewiseKrugerLogDiscount_times(PiecewiseKrugerLogDiscount self) -> DoubleVector"},
	 { "PiecewiseKrugerLogDiscount_nodes", _wrap_PiecewiseKrugerLogDiscount_nodes, METH_O, "PiecewiseKrugerLogDiscount_nodes(PiecewiseKrugerLogDiscount self) -> NodeVector"},
	 { "PiecewiseKrugerLogDiscount_recalculate", _wrap_PiecewiseKrugerLogDiscount_recalculate, METH_O, "PiecewiseKrugerLogDiscount_recalculate(PiecewiseKrugerLogDiscount self)"},
	 { "PiecewiseKrugerLogDiscount_freeze", _wrap_PiecewiseKrugerLogDiscount_freeze, METH_O, "PiecewiseKrugerLogDiscount_freeze(PiecewiseKrugerLogDiscount self)"},
	 { "PiecewiseKrugerLogDiscount_unfreeze", _wrap_PiecewiseKrugerLogDiscount_unfreeze, METH_O, "PiecewiseKrugerLogDiscount_unfreeze(PiecewiseKrugerLogDiscount self)"},
	 { "delete_PiecewiseKrugerLogDiscount", _wrap_delete_PiecewiseKrugerLogDiscount, METH_O, "delete_PiecewiseKrugerLogDiscount(PiecewiseKrugerLogDiscount self)"},
	 { "PiecewiseKrugerLogDiscount_swigregister", PiecewiseKrugerLogDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseKrugerLogDiscount_swiginit", PiecewiseKrugerLogDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseConvexMonotoneForward", _wrap_new_PiecewiseConvexMonotoneForward, METH_VARARGS, "\n"
		"PiecewiseConvexMonotoneForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), ConvexMonotone i=ConvexMonotone(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseConvexMonotoneForward(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), ConvexMonotone i=ConvexMonotone(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseConvexMonotoneForward(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, ConvexMonotone i=ConvexMonotone())\n"
		"PiecewiseConvexMonotoneForward(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, ConvexMonotone i=ConvexMonotone())\n"
		""},
	 { "PiecewiseConvexMonotoneForward_dates", _wrap_PiecewiseConvexMonotoneForward_dates, METH_O, "PiecewiseConvexMonotoneForward_dates(PiecewiseConvexMonotoneForward self) -> DateVector"},
	 { "PiecewiseConvexMonotoneForward_times", _wrap_PiecewiseConvexMonotoneForward_times, METH_O, "PiecewiseConvexMonotoneForward_times(PiecewiseConvexMonotoneForward self) -> DoubleVector"},
	 { "PiecewiseConvexMonotoneForward_nodes", _wrap_PiecewiseConvexMonotoneForward_nodes, METH_O, "PiecewiseConvexMonotoneForward_nodes(PiecewiseConvexMonotoneForward self) -> NodeVector"},
	 { "PiecewiseConvexMonotoneForward_recalculate", _wrap_PiecewiseConvexMonotoneForward_recalculate, METH_O, "PiecewiseConvexMonotoneForward_recalculate(PiecewiseConvexMonotoneForward self)"},
	 { "PiecewiseConvexMonotoneForward_freeze", _wrap_PiecewiseConvexMonotoneForward_freeze, METH_O, "PiecewiseConvexMonotoneForward_freeze(PiecewiseConvexMonotoneForward self)"},
	 { "PiecewiseConvexMonotoneForward_unfreeze", _wrap_PiecewiseConvexMonotoneForward_unfreeze, METH_O, "PiecewiseConvexMonotoneForward_unfreeze(PiecewiseConvexMonotoneForward self)"},
	 { "delete_PiecewiseConvexMonotoneForward", _wrap_delete_PiecewiseConvexMonotoneForward, METH_O, "delete_PiecewiseConvexMonotoneForward(PiecewiseConvexMonotoneForward self)"},
	 { "PiecewiseConvexMonotoneForward_swigregister", PiecewiseConvexMonotoneForward_swigregister, METH_O, NULL},
	 { "PiecewiseConvexMonotoneForward_swiginit", PiecewiseConvexMonotoneForward_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseConvexMonotoneZero", _wrap_new_PiecewiseConvexMonotoneZero, METH_VARARGS, "\n"
		"PiecewiseConvexMonotoneZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), ConvexMonotone i=ConvexMonotone(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseConvexMonotoneZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), ConvexMonotone i=ConvexMonotone(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseConvexMonotoneZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, ConvexMonotone i=ConvexMonotone())\n"
		"PiecewiseConvexMonotoneZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, ConvexMonotone i=ConvexMonotone())\n"
		""},
	 { "PiecewiseConvexMonotoneZero_dates", _wrap_PiecewiseConvexMonotoneZero_dates, METH_O, "PiecewiseConvexMonotoneZero_dates(PiecewiseConvexMonotoneZero self) -> DateVector"},
	 { "PiecewiseConvexMonotoneZero_times", _wrap_PiecewiseConvexMonotoneZero_times, METH_O, "PiecewiseConvexMonotoneZero_times(PiecewiseConvexMonotoneZero self) -> DoubleVector"},
	 { "PiecewiseConvexMonotoneZero_nodes", _wrap_PiecewiseConvexMonotoneZero_nodes, METH_O, "PiecewiseConvexMonotoneZero_nodes(PiecewiseConvexMonotoneZero self) -> NodeVector"},
	 { "PiecewiseConvexMonotoneZero_recalculate", _wrap_PiecewiseConvexMonotoneZero_recalculate, METH_O, "PiecewiseConvexMonotoneZero_recalculate(PiecewiseConvexMonotoneZero self)"},
	 { "PiecewiseConvexMonotoneZero_freeze", _wrap_PiecewiseConvexMonotoneZero_freeze, METH_O, "PiecewiseConvexMonotoneZero_freeze(PiecewiseConvexMonotoneZero self)"},
	 { "PiecewiseConvexMonotoneZero_unfreeze", _wrap_PiecewiseConvexMonotoneZero_unfreeze, METH_O, "PiecewiseConvexMonotoneZero_unfreeze(PiecewiseConvexMonotoneZero self)"},
	 { "delete_PiecewiseConvexMonotoneZero", _wrap_delete_PiecewiseConvexMonotoneZero, METH_O, "delete_PiecewiseConvexMonotoneZero(PiecewiseConvexMonotoneZero self)"},
	 { "PiecewiseConvexMonotoneZero_swigregister", PiecewiseConvexMonotoneZero_swigregister, METH_O, NULL},
	 { "PiecewiseConvexMonotoneZero_swiginit", PiecewiseConvexMonotoneZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseNaturalCubicZero", _wrap_new_PiecewiseNaturalCubicZero, METH_VARARGS, "\n"
		"PiecewiseNaturalCubicZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseNaturalCubicZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineCubic i=SplineCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseNaturalCubicZero(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, SplineCubic i=SplineCubic())\n"
		"PiecewiseNaturalCubicZero(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, SplineCubic i=SplineCubic())\n"
		""},
	 { "PiecewiseNaturalCubicZero_dates", _wrap_PiecewiseNaturalCubicZero_dates, METH_O, "PiecewiseNaturalCubicZero_dates(PiecewiseNaturalCubicZero self) -> DateVector"},
	 { "PiecewiseNaturalCubicZero_times", _wrap_PiecewiseNaturalCubicZero_times, METH_O, "PiecewiseNaturalCubicZero_times(PiecewiseNaturalCubicZero self) -> DoubleVector"},
	 { "PiecewiseNaturalCubicZero_nodes", _wrap_PiecewiseNaturalCubicZero_nodes, METH_O, "PiecewiseNaturalCubicZero_nodes(PiecewiseNaturalCubicZero self) -> NodeVector"},
	 { "PiecewiseNaturalCubicZero_recalculate", _wrap_PiecewiseNaturalCubicZero_recalculate, METH_O, "PiecewiseNaturalCubicZero_recalculate(PiecewiseNaturalCubicZero self)"},
	 { "PiecewiseNaturalCubicZero_freeze", _wrap_PiecewiseNaturalCubicZero_freeze, METH_O, "PiecewiseNaturalCubicZero_freeze(PiecewiseNaturalCubicZero self)"},
	 { "PiecewiseNaturalCubicZero_unfreeze", _wrap_PiecewiseNaturalCubicZero_unfreeze, METH_O, "PiecewiseNaturalCubicZero_unfreeze(PiecewiseNaturalCubicZero self)"},
	 { "delete_PiecewiseNaturalCubicZero", _wrap_delete_PiecewiseNaturalCubicZero, METH_O, "delete_PiecewiseNaturalCubicZero(PiecewiseNaturalCubicZero self)"},
	 { "PiecewiseNaturalCubicZero_swigregister", PiecewiseNaturalCubicZero_swigregister, METH_O, NULL},
	 { "PiecewiseNaturalCubicZero_swiginit", PiecewiseNaturalCubicZero_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseNaturalLogCubicDiscount", _wrap_new_PiecewiseNaturalLogCubicDiscount, METH_VARARGS, "\n"
		"PiecewiseNaturalLogCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineLogCubic i=SplineLogCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseNaturalLogCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), SplineLogCubic i=SplineLogCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseNaturalLogCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, SplineLogCubic i=SplineLogCubic())\n"
		"PiecewiseNaturalLogCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, SplineLogCubic i=SplineLogCubic())\n"
		""},
	 { "PiecewiseNaturalLogCubicDiscount_dates", _wrap_PiecewiseNaturalLogCubicDiscount_dates, METH_O, "PiecewiseNaturalLogCubicDiscount_dates(PiecewiseNaturalLogCubicDiscount self) -> DateVector"},
	 { "PiecewiseNaturalLogCubicDiscount_times", _wrap_PiecewiseNaturalLogCubicDiscount_times, METH_O, "PiecewiseNaturalLogCubicDiscount_times(PiecewiseNaturalLogCubicDiscount self) -> DoubleVector"},
	 { "PiecewiseNaturalLogCubicDiscount_nodes", _wrap_PiecewiseNaturalLogCubicDiscount_nodes, METH_O, "PiecewiseNaturalLogCubicDiscount_nodes(PiecewiseNaturalLogCubicDiscount self) -> NodeVector"},
	 { "PiecewiseNaturalLogCubicDiscount_recalculate", _wrap_PiecewiseNaturalLogCubicDiscount_recalculate, METH_O, "PiecewiseNaturalLogCubicDiscount_recalculate(PiecewiseNaturalLogCubicDiscount self)"},
	 { "PiecewiseNaturalLogCubicDiscount_freeze", _wrap_PiecewiseNaturalLogCubicDiscount_freeze, METH_O, "PiecewiseNaturalLogCubicDiscount_freeze(PiecewiseNaturalLogCubicDiscount self)"},
	 { "PiecewiseNaturalLogCubicDiscount_unfreeze", _wrap_PiecewiseNaturalLogCubicDiscount_unfreeze, METH_O, "PiecewiseNaturalLogCubicDiscount_unfreeze(PiecewiseNaturalLogCubicDiscount self)"},
	 { "delete_PiecewiseNaturalLogCubicDiscount", _wrap_delete_PiecewiseNaturalLogCubicDiscount, METH_O, "delete_PiecewiseNaturalLogCubicDiscount(PiecewiseNaturalLogCubicDiscount self)"},
	 { "PiecewiseNaturalLogCubicDiscount_swigregister", PiecewiseNaturalLogCubicDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseNaturalLogCubicDiscount_swiginit", PiecewiseNaturalLogCubicDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseLogMixedLinearCubicDiscount", _wrap_new_PiecewiseLogMixedLinearCubicDiscount, METH_VARARGS, "\n"
		"PiecewiseLogMixedLinearCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), LogMixedLinearCubic i=LogMixedLinearCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLogMixedLinearCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, QuoteHandleVector jumps=std::vector< Handle< Quote > >(), DateVector jumpDates=std::vector< Date >(), LogMixedLinearCubic i=LogMixedLinearCubic(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseLogMixedLinearCubicDiscount(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, LogMixedLinearCubic i=LogMixedLinearCubic())\n"
		"PiecewiseLogMixedLinearCubicDiscount(Integer settlementDays, Calendar calendar, RateHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b, LogMixedLinearCubic i=LogMixedLinearCubic())\n"
		""},
	 { "PiecewiseLogMixedLinearCubicDiscount_dates", _wrap_PiecewiseLogMixedLinearCubicDiscount_dates, METH_O, "PiecewiseLogMixedLinearCubicDiscount_dates(PiecewiseLogMixedLinearCubicDiscount self) -> DateVector"},
	 { "PiecewiseLogMixedLinearCubicDiscount_times", _wrap_PiecewiseLogMixedLinearCubicDiscount_times, METH_O, "PiecewiseLogMixedLinearCubicDiscount_times(PiecewiseLogMixedLinearCubicDiscount self) -> DoubleVector"},
	 { "PiecewiseLogMixedLinearCubicDiscount_nodes", _wrap_PiecewiseLogMixedLinearCubicDiscount_nodes, METH_O, "PiecewiseLogMixedLinearCubicDiscount_nodes(PiecewiseLogMixedLinearCubicDiscount self) -> NodeVector"},
	 { "PiecewiseLogMixedLinearCubicDiscount_recalculate", _wrap_PiecewiseLogMixedLinearCubicDiscount_recalculate, METH_O, "PiecewiseLogMixedLinearCubicDiscount_recalculate(PiecewiseLogMixedLinearCubicDiscount self)"},
	 { "PiecewiseLogMixedLinearCubicDiscount_freeze", _wrap_PiecewiseLogMixedLinearCubicDiscount_freeze, METH_O, "PiecewiseLogMixedLinearCubicDiscount_freeze(PiecewiseLogMixedLinearCubicDiscount self)"},
	 { "PiecewiseLogMixedLinearCubicDiscount_unfreeze", _wrap_PiecewiseLogMixedLinearCubicDiscount_unfreeze, METH_O, "PiecewiseLogMixedLinearCubicDiscount_unfreeze(PiecewiseLogMixedLinearCubicDiscount self)"},
	 { "delete_PiecewiseLogMixedLinearCubicDiscount", _wrap_delete_PiecewiseLogMixedLinearCubicDiscount, METH_O, "delete_PiecewiseLogMixedLinearCubicDiscount(PiecewiseLogMixedLinearCubicDiscount self)"},
	 { "PiecewiseLogMixedLinearCubicDiscount_swigregister", PiecewiseLogMixedLinearCubicDiscount_swigregister, METH_O, NULL},
	 { "PiecewiseLogMixedLinearCubicDiscount_swiginit", PiecewiseLogMixedLinearCubicDiscount_swiginit, METH_VARARGS, NULL},
	 { "new_GlobalBootstrap", _wrap_new_GlobalBootstrap, METH_VARARGS, "\n"
		"GlobalBootstrap(doubleOrNull accuracy=Null< double >())\n"
		"GlobalBootstrap(RateHelperVector additionalHelpers, DateVector additionalDates, doubleOrNull accuracy=Null< double >())\n"
		""},
	 { "delete_GlobalBootstrap", _wrap_delete_GlobalBootstrap, METH_O, "delete_GlobalBootstrap(GlobalBootstrap self)"},
	 { "GlobalBootstrap_swigregister", GlobalBootstrap_swigregister, METH_O, NULL},
	 { "GlobalBootstrap_swiginit", GlobalBootstrap_swiginit, METH_VARARGS, NULL},
	 { "new_GlobalLinearSimpleZeroCurve", _wrap_new_GlobalLinearSimpleZeroCurve, METH_VARARGS, "new_GlobalLinearSimpleZeroCurve(Date referenceDate, RateHelperVector instruments, DayCounter dayCounter, GlobalBootstrap b) -> GlobalLinearSimpleZeroCurve"},
	 { "GlobalLinearSimpleZeroCurve_dates", _wrap_GlobalLinearSimpleZeroCurve_dates, METH_O, "GlobalLinearSimpleZeroCurve_dates(GlobalLinearSimpleZeroCurve self) -> DateVector"},
	 { "GlobalLinearSimpleZeroCurve_times", _wrap_GlobalLinearSimpleZeroCurve_times, METH_O, "GlobalLinearSimpleZeroCurve_times(GlobalLinearSimpleZeroCurve self) -> DoubleVector"},
	 { "GlobalLinearSimpleZeroCurve_nodes", _wrap_GlobalLinearSimpleZeroCurve_nodes, METH_O, "GlobalLinearSimpleZeroCurve_nodes(GlobalLinearSimpleZeroCurve self) -> NodeVector"},
	 { "delete_GlobalLinearSimpleZeroCurve", _wrap_delete_GlobalLinearSimpleZeroCurve, METH_O, "delete_GlobalLinearSimpleZeroCurve(GlobalLinearSimpleZeroCurve self)"},
	 { "GlobalLinearSimpleZeroCurve_swigregister", GlobalLinearSimpleZeroCurve_swigregister, METH_O, NULL},
	 { "GlobalLinearSimpleZeroCurve_swiginit", GlobalLinearSimpleZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "DefaultProbabilityTermStructure_defaultProbability", _wrap_DefaultProbabilityTermStructure_defaultProbability, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructure_defaultProbability(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructure_defaultProbability(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructure_defaultProbability(DefaultProbabilityTermStructure self, Date arg2, Date arg3, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructure_defaultProbability(DefaultProbabilityTermStructure self, Time arg2, Time arg3, bool extrapolate=False) -> Probability\n"
		""},
	 { "DefaultProbabilityTermStructure_survivalProbability", _wrap_DefaultProbabilityTermStructure_survivalProbability, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructure_survivalProbability(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructure_survivalProbability(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Probability\n"
		""},
	 { "DefaultProbabilityTermStructure_defaultDensity", _wrap_DefaultProbabilityTermStructure_defaultDensity, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructure_defaultDensity(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Real\n"
		"DefaultProbabilityTermStructure_defaultDensity(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Real\n"
		""},
	 { "DefaultProbabilityTermStructure_hazardRate", _wrap_DefaultProbabilityTermStructure_hazardRate, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructure_hazardRate(DefaultProbabilityTermStructure self, Date arg2, bool extrapolate=False) -> Real\n"
		"DefaultProbabilityTermStructure_hazardRate(DefaultProbabilityTermStructure self, Time arg2, bool extrapolate=False) -> Real\n"
		""},
	 { "delete_DefaultProbabilityTermStructure", _wrap_delete_DefaultProbabilityTermStructure, METH_O, "delete_DefaultProbabilityTermStructure(DefaultProbabilityTermStructure self)"},
	 { "DefaultProbabilityTermStructure_swigregister", DefaultProbabilityTermStructure_swigregister, METH_O, NULL},
	 { "new_DefaultProbabilityTermStructureHandle", _wrap_new_DefaultProbabilityTermStructureHandle, METH_VARARGS, "DefaultProbabilityTermStructureHandle(ext::shared_ptr< DefaultProbabilityTermStructure > const & arg1=ext::shared_ptr())"},
	 { "DefaultProbabilityTermStructureHandle___deref__", _wrap_DefaultProbabilityTermStructureHandle___deref__, METH_O, "DefaultProbabilityTermStructureHandle___deref__(DefaultProbabilityTermStructureHandle self) -> ext::shared_ptr< DefaultProbabilityTermStructure >"},
	 { "DefaultProbabilityTermStructureHandle_currentLink", _wrap_DefaultProbabilityTermStructureHandle_currentLink, METH_O, "DefaultProbabilityTermStructureHandle_currentLink(DefaultProbabilityTermStructureHandle self) -> ext::shared_ptr< DefaultProbabilityTermStructure >"},
	 { "DefaultProbabilityTermStructureHandle___nonzero__", _wrap_DefaultProbabilityTermStructureHandle___nonzero__, METH_O, "DefaultProbabilityTermStructureHandle___nonzero__(DefaultProbabilityTermStructureHandle self) -> bool"},
	 { "DefaultProbabilityTermStructureHandle___bool__", _wrap_DefaultProbabilityTermStructureHandle___bool__, METH_O, "DefaultProbabilityTermStructureHandle___bool__(DefaultProbabilityTermStructureHandle self) -> bool"},
	 { "DefaultProbabilityTermStructureHandle_asObservable", _wrap_DefaultProbabilityTermStructureHandle_asObservable, METH_O, "DefaultProbabilityTermStructureHandle_asObservable(DefaultProbabilityTermStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_DefaultProbabilityTermStructureHandle", _wrap_delete_DefaultProbabilityTermStructureHandle, METH_O, "delete_DefaultProbabilityTermStructureHandle(DefaultProbabilityTermStructureHandle self)"},
	 { "DefaultProbabilityTermStructureHandle_defaultProbability", _wrap_DefaultProbabilityTermStructureHandle_defaultProbability, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructureHandle_defaultProbability(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructureHandle_defaultProbability(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructureHandle_defaultProbability(DefaultProbabilityTermStructureHandle self, Date arg2, Date arg3, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructureHandle_defaultProbability(DefaultProbabilityTermStructureHandle self, Time arg2, Time arg3, bool extrapolate=False) -> Probability\n"
		""},
	 { "DefaultProbabilityTermStructureHandle_survivalProbability", _wrap_DefaultProbabilityTermStructureHandle_survivalProbability, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructureHandle_survivalProbability(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Probability\n"
		"DefaultProbabilityTermStructureHandle_survivalProbability(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Probability\n"
		""},
	 { "DefaultProbabilityTermStructureHandle_defaultDensity", _wrap_DefaultProbabilityTermStructureHandle_defaultDensity, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructureHandle_defaultDensity(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Real\n"
		"DefaultProbabilityTermStructureHandle_defaultDensity(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Real\n"
		""},
	 { "DefaultProbabilityTermStructureHandle_hazardRate", _wrap_DefaultProbabilityTermStructureHandle_hazardRate, METH_VARARGS, "\n"
		"DefaultProbabilityTermStructureHandle_hazardRate(DefaultProbabilityTermStructureHandle self, Date arg2, bool extrapolate=False) -> Real\n"
		"DefaultProbabilityTermStructureHandle_hazardRate(DefaultProbabilityTermStructureHandle self, Time arg2, bool extrapolate=False) -> Real\n"
		""},
	 { "DefaultProbabilityTermStructureHandle_dayCounter", _wrap_DefaultProbabilityTermStructureHandle_dayCounter, METH_O, "DefaultProbabilityTermStructureHandle_dayCounter(DefaultProbabilityTermStructureHandle self) -> DayCounter"},
	 { "DefaultProbabilityTermStructureHandle_timeFromReference", _wrap_DefaultProbabilityTermStructureHandle_timeFromReference, METH_VARARGS, "DefaultProbabilityTermStructureHandle_timeFromReference(DefaultProbabilityTermStructureHandle self, Date date) -> Time"},
	 { "DefaultProbabilityTermStructureHandle_calendar", _wrap_DefaultProbabilityTermStructureHandle_calendar, METH_O, "DefaultProbabilityTermStructureHandle_calendar(DefaultProbabilityTermStructureHandle self) -> Calendar"},
	 { "DefaultProbabilityTermStructureHandle_referenceDate", _wrap_DefaultProbabilityTermStructureHandle_referenceDate, METH_O, "DefaultProbabilityTermStructureHandle_referenceDate(DefaultProbabilityTermStructureHandle self) -> Date"},
	 { "DefaultProbabilityTermStructureHandle_maxDate", _wrap_DefaultProbabilityTermStructureHandle_maxDate, METH_O, "DefaultProbabilityTermStructureHandle_maxDate(DefaultProbabilityTermStructureHandle self) -> Date"},
	 { "DefaultProbabilityTermStructureHandle_maxTime", _wrap_DefaultProbabilityTermStructureHandle_maxTime, METH_O, "DefaultProbabilityTermStructureHandle_maxTime(DefaultProbabilityTermStructureHandle self) -> Time"},
	 { "DefaultProbabilityTermStructureHandle_enableExtrapolation", _wrap_DefaultProbabilityTermStructureHandle_enableExtrapolation, METH_O, "DefaultProbabilityTermStructureHandle_enableExtrapolation(DefaultProbabilityTermStructureHandle self)"},
	 { "DefaultProbabilityTermStructureHandle_disableExtrapolation", _wrap_DefaultProbabilityTermStructureHandle_disableExtrapolation, METH_O, "DefaultProbabilityTermStructureHandle_disableExtrapolation(DefaultProbabilityTermStructureHandle self)"},
	 { "DefaultProbabilityTermStructureHandle_allowsExtrapolation", _wrap_DefaultProbabilityTermStructureHandle_allowsExtrapolation, METH_O, "DefaultProbabilityTermStructureHandle_allowsExtrapolation(DefaultProbabilityTermStructureHandle self) -> bool"},
	 { "DefaultProbabilityTermStructureHandle_swigregister", DefaultProbabilityTermStructureHandle_swigregister, METH_O, NULL},
	 { "DefaultProbabilityTermStructureHandle_swiginit", DefaultProbabilityTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableDefaultProbabilityTermStructureHandle", _wrap_new_RelinkableDefaultProbabilityTermStructureHandle, METH_VARARGS, "RelinkableDefaultProbabilityTermStructureHandle(ext::shared_ptr< DefaultProbabilityTermStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableDefaultProbabilityTermStructureHandle_linkTo", _wrap_RelinkableDefaultProbabilityTermStructureHandle_linkTo, METH_VARARGS, "RelinkableDefaultProbabilityTermStructureHandle_linkTo(RelinkableDefaultProbabilityTermStructureHandle self, ext::shared_ptr< DefaultProbabilityTermStructure > const & arg2)"},
	 { "RelinkableDefaultProbabilityTermStructureHandle_reset", _wrap_RelinkableDefaultProbabilityTermStructureHandle_reset, METH_O, "RelinkableDefaultProbabilityTermStructureHandle_reset(RelinkableDefaultProbabilityTermStructureHandle self)"},
	 { "delete_RelinkableDefaultProbabilityTermStructureHandle", _wrap_delete_RelinkableDefaultProbabilityTermStructureHandle, METH_O, "delete_RelinkableDefaultProbabilityTermStructureHandle(RelinkableDefaultProbabilityTermStructureHandle self)"},
	 { "RelinkableDefaultProbabilityTermStructureHandle_swigregister", RelinkableDefaultProbabilityTermStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableDefaultProbabilityTermStructureHandle_swiginit", RelinkableDefaultProbabilityTermStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_FlatHazardRate", _wrap_new_FlatHazardRate, METH_VARARGS, "\n"
		"FlatHazardRate(Integer settlementDays, Calendar calendar, QuoteHandle hazardRate, DayCounter dayCounter)\n"
		"new_FlatHazardRate(Date todaysDate, QuoteHandle hazardRate, DayCounter dayCounter) -> FlatHazardRate\n"
		""},
	 { "delete_FlatHazardRate", _wrap_delete_FlatHazardRate, METH_O, "delete_FlatHazardRate(FlatHazardRate self)"},
	 { "FlatHazardRate_swigregister", FlatHazardRate_swigregister, METH_O, NULL},
	 { "FlatHazardRate_swiginit", FlatHazardRate_swiginit, METH_VARARGS, NULL},
	 { "new_HazardRateCurve", _wrap_new_HazardRateCurve, METH_VARARGS, "HazardRateCurve(DateVector dates, DoubleVector hazardRates, DayCounter dayCounter, Calendar calendar=Calendar(), BackwardFlat i=BackwardFlat())"},
	 { "HazardRateCurve_dates", _wrap_HazardRateCurve_dates, METH_O, "HazardRateCurve_dates(HazardRateCurve self) -> DateVector"},
	 { "HazardRateCurve_hazardRates", _wrap_HazardRateCurve_hazardRates, METH_O, "HazardRateCurve_hazardRates(HazardRateCurve self) -> DoubleVector"},
	 { "HazardRateCurve_nodes", _wrap_HazardRateCurve_nodes, METH_O, "HazardRateCurve_nodes(HazardRateCurve self) -> NodeVector"},
	 { "delete_HazardRateCurve", _wrap_delete_HazardRateCurve, METH_O, "delete_HazardRateCurve(HazardRateCurve self)"},
	 { "HazardRateCurve_swigregister", HazardRateCurve_swigregister, METH_O, NULL},
	 { "HazardRateCurve_swiginit", HazardRateCurve_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultDensityCurve", _wrap_new_DefaultDensityCurve, METH_VARARGS, "DefaultDensityCurve(DateVector dates, DoubleVector densities, DayCounter dayCounter, Calendar calendar=Calendar(), Linear i=Linear())"},
	 { "DefaultDensityCurve_dates", _wrap_DefaultDensityCurve_dates, METH_O, "DefaultDensityCurve_dates(DefaultDensityCurve self) -> DateVector"},
	 { "DefaultDensityCurve_defaultDensities", _wrap_DefaultDensityCurve_defaultDensities, METH_O, "DefaultDensityCurve_defaultDensities(DefaultDensityCurve self) -> DoubleVector"},
	 { "DefaultDensityCurve_nodes", _wrap_DefaultDensityCurve_nodes, METH_O, "DefaultDensityCurve_nodes(DefaultDensityCurve self) -> NodeVector"},
	 { "delete_DefaultDensityCurve", _wrap_delete_DefaultDensityCurve, METH_O, "delete_DefaultDensityCurve(DefaultDensityCurve self)"},
	 { "DefaultDensityCurve_swigregister", DefaultDensityCurve_swigregister, METH_O, NULL},
	 { "DefaultDensityCurve_swiginit", DefaultDensityCurve_swiginit, METH_VARARGS, NULL},
	 { "new_SurvivalProbabilityCurve", _wrap_new_SurvivalProbabilityCurve, METH_VARARGS, "SurvivalProbabilityCurve(DateVector dates, DoubleVector probabilities, DayCounter dayCounter, Calendar calendar=Calendar(), Linear i=Linear())"},
	 { "SurvivalProbabilityCurve_dates", _wrap_SurvivalProbabilityCurve_dates, METH_O, "SurvivalProbabilityCurve_dates(SurvivalProbabilityCurve self) -> DateVector"},
	 { "SurvivalProbabilityCurve_survivalProbabilities", _wrap_SurvivalProbabilityCurve_survivalProbabilities, METH_O, "SurvivalProbabilityCurve_survivalProbabilities(SurvivalProbabilityCurve self) -> DoubleVector"},
	 { "SurvivalProbabilityCurve_nodes", _wrap_SurvivalProbabilityCurve_nodes, METH_O, "SurvivalProbabilityCurve_nodes(SurvivalProbabilityCurve self) -> NodeVector"},
	 { "delete_SurvivalProbabilityCurve", _wrap_delete_SurvivalProbabilityCurve, METH_O, "delete_SurvivalProbabilityCurve(SurvivalProbabilityCurve self)"},
	 { "SurvivalProbabilityCurve_swigregister", SurvivalProbabilityCurve_swigregister, METH_O, NULL},
	 { "SurvivalProbabilityCurve_swiginit", SurvivalProbabilityCurve_swiginit, METH_VARARGS, NULL},
	 { "DefaultProbabilityHelper_quote", _wrap_DefaultProbabilityHelper_quote, METH_O, "DefaultProbabilityHelper_quote(DefaultProbabilityHelper self) -> QuoteHandle"},
	 { "DefaultProbabilityHelper_latestDate", _wrap_DefaultProbabilityHelper_latestDate, METH_O, "DefaultProbabilityHelper_latestDate(DefaultProbabilityHelper self) -> Date"},
	 { "DefaultProbabilityHelper_earliestDate", _wrap_DefaultProbabilityHelper_earliestDate, METH_O, "DefaultProbabilityHelper_earliestDate(DefaultProbabilityHelper self) -> Date"},
	 { "DefaultProbabilityHelper_maturityDate", _wrap_DefaultProbabilityHelper_maturityDate, METH_O, "DefaultProbabilityHelper_maturityDate(DefaultProbabilityHelper self) -> Date"},
	 { "DefaultProbabilityHelper_latestRelevantDate", _wrap_DefaultProbabilityHelper_latestRelevantDate, METH_O, "DefaultProbabilityHelper_latestRelevantDate(DefaultProbabilityHelper self) -> Date"},
	 { "DefaultProbabilityHelper_pillarDate", _wrap_DefaultProbabilityHelper_pillarDate, METH_O, "DefaultProbabilityHelper_pillarDate(DefaultProbabilityHelper self) -> Date"},
	 { "DefaultProbabilityHelper_impliedQuote", _wrap_DefaultProbabilityHelper_impliedQuote, METH_O, "DefaultProbabilityHelper_impliedQuote(DefaultProbabilityHelper self) -> Real"},
	 { "DefaultProbabilityHelper_quoteError", _wrap_DefaultProbabilityHelper_quoteError, METH_O, "DefaultProbabilityHelper_quoteError(DefaultProbabilityHelper self) -> Real"},
	 { "delete_DefaultProbabilityHelper", _wrap_delete_DefaultProbabilityHelper, METH_O, "delete_DefaultProbabilityHelper(DefaultProbabilityHelper self)"},
	 { "DefaultProbabilityHelper_swigregister", DefaultProbabilityHelper_swigregister, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_iterator", _wrap_DefaultProbabilityHelperVector_iterator, METH_O, "DefaultProbabilityHelperVector_iterator(DefaultProbabilityHelperVector self) -> SwigPyIterator"},
	 { "DefaultProbabilityHelperVector___nonzero__", _wrap_DefaultProbabilityHelperVector___nonzero__, METH_O, "DefaultProbabilityHelperVector___nonzero__(DefaultProbabilityHelperVector self) -> bool"},
	 { "DefaultProbabilityHelperVector___bool__", _wrap_DefaultProbabilityHelperVector___bool__, METH_O, "DefaultProbabilityHelperVector___bool__(DefaultProbabilityHelperVector self) -> bool"},
	 { "DefaultProbabilityHelperVector___len__", _wrap_DefaultProbabilityHelperVector___len__, METH_O, "DefaultProbabilityHelperVector___len__(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type"},
	 { "DefaultProbabilityHelperVector___getslice__", _wrap_DefaultProbabilityHelperVector___getslice__, METH_VARARGS, "DefaultProbabilityHelperVector___getslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j) -> DefaultProbabilityHelperVector"},
	 { "DefaultProbabilityHelperVector___setslice__", _wrap_DefaultProbabilityHelperVector___setslice__, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector___setslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j)\n"
		"DefaultProbabilityHelperVector___setslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j, DefaultProbabilityHelperVector v)\n"
		""},
	 { "DefaultProbabilityHelperVector___delslice__", _wrap_DefaultProbabilityHelperVector___delslice__, METH_VARARGS, "DefaultProbabilityHelperVector___delslice__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type j)"},
	 { "DefaultProbabilityHelperVector___delitem__", _wrap_DefaultProbabilityHelperVector___delitem__, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector___delitem__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i)\n"
		"DefaultProbabilityHelperVector___delitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "DefaultProbabilityHelperVector___getitem__", _wrap_DefaultProbabilityHelperVector___getitem__, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector___getitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice) -> DefaultProbabilityHelperVector\n"
		"DefaultProbabilityHelperVector___getitem__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &\n"
		""},
	 { "DefaultProbabilityHelperVector___setitem__", _wrap_DefaultProbabilityHelperVector___setitem__, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector___setitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice, DefaultProbabilityHelperVector v)\n"
		"DefaultProbabilityHelperVector___setitem__(DefaultProbabilityHelperVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"DefaultProbabilityHelperVector___setitem__(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::difference_type i, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)\n"
		""},
	 { "DefaultProbabilityHelperVector_pop", _wrap_DefaultProbabilityHelperVector_pop, METH_O, "DefaultProbabilityHelperVector_pop(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type"},
	 { "DefaultProbabilityHelperVector_append", _wrap_DefaultProbabilityHelperVector_append, METH_VARARGS, "DefaultProbabilityHelperVector_append(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)"},
	 { "DefaultProbabilityHelperVector_empty", _wrap_DefaultProbabilityHelperVector_empty, METH_O, "DefaultProbabilityHelperVector_empty(DefaultProbabilityHelperVector self) -> bool"},
	 { "DefaultProbabilityHelperVector_size", _wrap_DefaultProbabilityHelperVector_size, METH_O, "DefaultProbabilityHelperVector_size(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type"},
	 { "DefaultProbabilityHelperVector_swap", _wrap_DefaultProbabilityHelperVector_swap, METH_VARARGS, "DefaultProbabilityHelperVector_swap(DefaultProbabilityHelperVector self, DefaultProbabilityHelperVector v)"},
	 { "DefaultProbabilityHelperVector_begin", _wrap_DefaultProbabilityHelperVector_begin, METH_O, "DefaultProbabilityHelperVector_begin(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator"},
	 { "DefaultProbabilityHelperVector_end", _wrap_DefaultProbabilityHelperVector_end, METH_O, "DefaultProbabilityHelperVector_end(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator"},
	 { "DefaultProbabilityHelperVector_rbegin", _wrap_DefaultProbabilityHelperVector_rbegin, METH_O, "DefaultProbabilityHelperVector_rbegin(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator"},
	 { "DefaultProbabilityHelperVector_rend", _wrap_DefaultProbabilityHelperVector_rend, METH_O, "DefaultProbabilityHelperVector_rend(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::reverse_iterator"},
	 { "DefaultProbabilityHelperVector_clear", _wrap_DefaultProbabilityHelperVector_clear, METH_O, "DefaultProbabilityHelperVector_clear(DefaultProbabilityHelperVector self)"},
	 { "DefaultProbabilityHelperVector_get_allocator", _wrap_DefaultProbabilityHelperVector_get_allocator, METH_O, "DefaultProbabilityHelperVector_get_allocator(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::allocator_type"},
	 { "DefaultProbabilityHelperVector_pop_back", _wrap_DefaultProbabilityHelperVector_pop_back, METH_O, "DefaultProbabilityHelperVector_pop_back(DefaultProbabilityHelperVector self)"},
	 { "DefaultProbabilityHelperVector_erase", _wrap_DefaultProbabilityHelperVector_erase, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector_erase(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator\n"
		"DefaultProbabilityHelperVector_erase(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator first, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator last) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator\n"
		""},
	 { "new_DefaultProbabilityHelperVector", _wrap_new_DefaultProbabilityHelperVector, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector()\n"
		"DefaultProbabilityHelperVector(DefaultProbabilityHelperVector other)\n"
		"DefaultProbabilityHelperVector(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type size)\n"
		"new_DefaultProbabilityHelperVector(std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type size, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & value) -> DefaultProbabilityHelperVector\n"
		""},
	 { "DefaultProbabilityHelperVector_push_back", _wrap_DefaultProbabilityHelperVector_push_back, METH_VARARGS, "DefaultProbabilityHelperVector_push_back(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)"},
	 { "DefaultProbabilityHelperVector_front", _wrap_DefaultProbabilityHelperVector_front, METH_O, "DefaultProbabilityHelperVector_front(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &"},
	 { "DefaultProbabilityHelperVector_back", _wrap_DefaultProbabilityHelperVector_back, METH_O, "DefaultProbabilityHelperVector_back(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const &"},
	 { "DefaultProbabilityHelperVector_assign", _wrap_DefaultProbabilityHelperVector_assign, METH_VARARGS, "DefaultProbabilityHelperVector_assign(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)"},
	 { "DefaultProbabilityHelperVector_resize", _wrap_DefaultProbabilityHelperVector_resize, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector_resize(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type new_size)\n"
		"DefaultProbabilityHelperVector_resize(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type new_size, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)\n"
		""},
	 { "DefaultProbabilityHelperVector_insert", _wrap_DefaultProbabilityHelperVector_insert, METH_VARARGS, "\n"
		"DefaultProbabilityHelperVector_insert(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator\n"
		"DefaultProbabilityHelperVector_insert(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::iterator pos, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::value_type const & x)\n"
		""},
	 { "DefaultProbabilityHelperVector_reserve", _wrap_DefaultProbabilityHelperVector_reserve, METH_VARARGS, "DefaultProbabilityHelperVector_reserve(DefaultProbabilityHelperVector self, std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type n)"},
	 { "DefaultProbabilityHelperVector_capacity", _wrap_DefaultProbabilityHelperVector_capacity, METH_O, "DefaultProbabilityHelperVector_capacity(DefaultProbabilityHelperVector self) -> std::vector< ext::shared_ptr< DefaultProbabilityHelper > >::size_type"},
	 { "delete_DefaultProbabilityHelperVector", _wrap_delete_DefaultProbabilityHelperVector, METH_O, "delete_DefaultProbabilityHelperVector(DefaultProbabilityHelperVector self)"},
	 { "DefaultProbabilityHelperVector_swigregister", DefaultProbabilityHelperVector_swigregister, METH_O, NULL},
	 { "DefaultProbabilityHelperVector_swiginit", DefaultProbabilityHelperVector_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadCdsHelper", _wrap_new_SpreadCdsHelper, METH_VARARGS, "\n"
		"SpreadCdsHelper(QuoteHandle spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint)\n"
		"SpreadCdsHelper(Rate spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint)\n"
		""},
	 { "delete_SpreadCdsHelper", _wrap_delete_SpreadCdsHelper, METH_O, "delete_SpreadCdsHelper(SpreadCdsHelper self)"},
	 { "SpreadCdsHelper_swigregister", SpreadCdsHelper_swigregister, METH_O, NULL},
	 { "SpreadCdsHelper_swiginit", SpreadCdsHelper_swiginit, METH_VARARGS, NULL},
	 { "new_UpfrontCdsHelper", _wrap_new_UpfrontCdsHelper, METH_VARARGS, "\n"
		"UpfrontCdsHelper(QuoteHandle upfront, Rate spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, Natural upfrontSettlementDays=0, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint)\n"
		"UpfrontCdsHelper(Rate upfront, Rate spread, Period tenor, Integer settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration::Rule rule, DayCounter dayCounter, Real recoveryRate, YieldTermStructureHandle discountCurve, Natural upfrontSettlementDays=0, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date startDate=Date(), DayCounter lastPeriodDayCounter=DayCounter(), bool rebatesAccrual=True, CreditDefaultSwap::PricingModel model=Midpoint)\n"
		""},
	 { "delete_UpfrontCdsHelper", _wrap_delete_UpfrontCdsHelper, METH_O, "delete_UpfrontCdsHelper(UpfrontCdsHelper self)"},
	 { "UpfrontCdsHelper_swigregister", UpfrontCdsHelper_swigregister, METH_O, NULL},
	 { "UpfrontCdsHelper_swiginit", UpfrontCdsHelper_swiginit, METH_VARARGS, NULL},
	 { "new_HazardRate", _wrap_new_HazardRate, METH_NOARGS, "new_HazardRate() -> HazardRate"},
	 { "delete_HazardRate", _wrap_delete_HazardRate, METH_O, "delete_HazardRate(HazardRate self)"},
	 { "HazardRate_swigregister", HazardRate_swigregister, METH_O, NULL},
	 { "HazardRate_swiginit", HazardRate_swiginit, METH_VARARGS, NULL},
	 { "new_DefaultDensity", _wrap_new_DefaultDensity, METH_NOARGS, "new_DefaultDensity() -> DefaultDensity"},
	 { "delete_DefaultDensity", _wrap_delete_DefaultDensity, METH_O, "delete_DefaultDensity(DefaultDensity self)"},
	 { "DefaultDensity_swigregister", DefaultDensity_swigregister, METH_O, NULL},
	 { "DefaultDensity_swiginit", DefaultDensity_swiginit, METH_VARARGS, NULL},
	 { "new_PiecewiseFlatHazardRate", _wrap_new_PiecewiseFlatHazardRate, METH_VARARGS, "\n"
		"PiecewiseFlatHazardRate(Date referenceDate, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseFlatHazardRate(Integer settlementDays, Calendar calendar, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, BackwardFlat i=BackwardFlat(), IterativeBootstrap b=_IterativeBootstrap())\n"
		"PiecewiseFlatHazardRate(Date referenceDate, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b)\n"
		"new_PiecewiseFlatHazardRate(Integer settlementDays, Calendar calendar, DefaultProbabilityHelperVector instruments, DayCounter dayCounter, IterativeBootstrap b) -> PiecewiseFlatHazardRate\n"
		""},
	 { "PiecewiseFlatHazardRate_dates", _wrap_PiecewiseFlatHazardRate_dates, METH_O, "PiecewiseFlatHazardRate_dates(PiecewiseFlatHazardRate self) -> DateVector"},
	 { "PiecewiseFlatHazardRate_times", _wrap_PiecewiseFlatHazardRate_times, METH_O, "PiecewiseFlatHazardRate_times(PiecewiseFlatHazardRate self) -> DoubleVector"},
	 { "PiecewiseFlatHazardRate_nodes", _wrap_PiecewiseFlatHazardRate_nodes, METH_O, "PiecewiseFlatHazardRate_nodes(PiecewiseFlatHazardRate self) -> NodeVector"},
	 { "delete_PiecewiseFlatHazardRate", _wrap_delete_PiecewiseFlatHazardRate, METH_O, "delete_PiecewiseFlatHazardRate(PiecewiseFlatHazardRate self)"},
	 { "PiecewiseFlatHazardRate_swigregister", PiecewiseFlatHazardRate_swigregister, METH_O, NULL},
	 { "PiecewiseFlatHazardRate_swiginit", PiecewiseFlatHazardRate_swiginit, METH_VARARGS, NULL},
	 { "new_RiskyBondEngine", _wrap_new_RiskyBondEngine, METH_VARARGS, "new_RiskyBondEngine(DefaultProbabilityTermStructureHandle defaultCurve, Real recoveryRate, YieldTermStructureHandle riskFreeCurve) -> RiskyBondEngine"},
	 { "delete_RiskyBondEngine", _wrap_delete_RiskyBondEngine, METH_O, "delete_RiskyBondEngine(RiskyBondEngine self)"},
	 { "RiskyBondEngine_swigregister", RiskyBondEngine_swigregister, METH_O, NULL},
	 { "RiskyBondEngine_swiginit", RiskyBondEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Protection", _wrap_new_Protection, METH_NOARGS, "new_Protection() -> Protection"},
	 { "delete_Protection", _wrap_delete_Protection, METH_O, "delete_Protection(Protection self)"},
	 { "Protection_swigregister", Protection_swigregister, METH_O, NULL},
	 { "Protection_swiginit", Protection_swiginit, METH_VARARGS, NULL},
	 { "Claim_amount", _wrap_Claim_amount, METH_VARARGS, "Claim_amount(Claim self, Date defaultDate, Real notional, Real recoveryRate) -> Real"},
	 { "delete_Claim", _wrap_delete_Claim, METH_O, "delete_Claim(Claim self)"},
	 { "Claim_swigregister", Claim_swigregister, METH_O, NULL},
	 { "new_FaceValueClaim", _wrap_new_FaceValueClaim, METH_NOARGS, "new_FaceValueClaim() -> FaceValueClaim"},
	 { "delete_FaceValueClaim", _wrap_delete_FaceValueClaim, METH_O, "delete_FaceValueClaim(FaceValueClaim self)"},
	 { "FaceValueClaim_swigregister", FaceValueClaim_swigregister, METH_O, NULL},
	 { "FaceValueClaim_swiginit", FaceValueClaim_swiginit, METH_VARARGS, NULL},
	 { "new_FaceValueAccrualClaim", _wrap_new_FaceValueAccrualClaim, METH_O, "new_FaceValueAccrualClaim(ext::shared_ptr< Bond > const & bond) -> FaceValueAccrualClaim"},
	 { "delete_FaceValueAccrualClaim", _wrap_delete_FaceValueAccrualClaim, METH_O, "delete_FaceValueAccrualClaim(FaceValueAccrualClaim self)"},
	 { "FaceValueAccrualClaim_swigregister", FaceValueAccrualClaim_swigregister, METH_O, NULL},
	 { "FaceValueAccrualClaim_swiginit", FaceValueAccrualClaim_swiginit, METH_VARARGS, NULL},
	 { "new_CreditDefaultSwap", _wrap_new_CreditDefaultSwap, METH_VARARGS, "\n"
		"CreditDefaultSwap(Protection::Side side, Real notional, Rate spread, Schedule schedule, BusinessDayConvention paymentConvention, DayCounter dayCounter, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date protectionStart=Date(), ext::shared_ptr< Claim > const & claim={}, DayCounter lastPeriodDayCounter=DayCounter(), bool const rebatesAccrual=True, Date tradeDate=Date(), Natural cashSettlementDays=3)\n"
		"CreditDefaultSwap(Protection::Side side, Real notional, Rate upfront, Rate spread, Schedule schedule, BusinessDayConvention paymentConvention, DayCounter dayCounter, bool settlesAccrual=True, bool paysAtDefaultTime=True, Date protectionStart=Date(), Date upfrontDate=Date(), ext::shared_ptr< Claim > const & claim={}, DayCounter lastPeriodDayCounter=DayCounter(), bool const rebatesAccrual=True, Date tradeDate=Date(), Natural cashSettlementDays=3)\n"
		""},
	 { "CreditDefaultSwap_side", _wrap_CreditDefaultSwap_side, METH_O, "CreditDefaultSwap_side(CreditDefaultSwap self) -> Protection::Side"},
	 { "CreditDefaultSwap_notional", _wrap_CreditDefaultSwap_notional, METH_O, "CreditDefaultSwap_notional(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_runningSpread", _wrap_CreditDefaultSwap_runningSpread, METH_O, "CreditDefaultSwap_runningSpread(CreditDefaultSwap self) -> Rate"},
	 { "CreditDefaultSwap_upfront", _wrap_CreditDefaultSwap_upfront, METH_O, "CreditDefaultSwap_upfront(CreditDefaultSwap self) -> doubleOrNull"},
	 { "CreditDefaultSwap_settlesAccrual", _wrap_CreditDefaultSwap_settlesAccrual, METH_O, "CreditDefaultSwap_settlesAccrual(CreditDefaultSwap self) -> bool"},
	 { "CreditDefaultSwap_paysAtDefaultTime", _wrap_CreditDefaultSwap_paysAtDefaultTime, METH_O, "CreditDefaultSwap_paysAtDefaultTime(CreditDefaultSwap self) -> bool"},
	 { "CreditDefaultSwap_coupons", _wrap_CreditDefaultSwap_coupons, METH_O, "CreditDefaultSwap_coupons(CreditDefaultSwap self) -> Leg"},
	 { "CreditDefaultSwap_protectionStartDate", _wrap_CreditDefaultSwap_protectionStartDate, METH_O, "CreditDefaultSwap_protectionStartDate(CreditDefaultSwap self) -> Date"},
	 { "CreditDefaultSwap_protectionEndDate", _wrap_CreditDefaultSwap_protectionEndDate, METH_O, "CreditDefaultSwap_protectionEndDate(CreditDefaultSwap self) -> Date"},
	 { "CreditDefaultSwap_rebatesAccrual", _wrap_CreditDefaultSwap_rebatesAccrual, METH_O, "CreditDefaultSwap_rebatesAccrual(CreditDefaultSwap self) -> bool"},
	 { "CreditDefaultSwap_upfrontPayment", _wrap_CreditDefaultSwap_upfrontPayment, METH_O, "CreditDefaultSwap_upfrontPayment(CreditDefaultSwap self) -> ext::shared_ptr< CashFlow >"},
	 { "CreditDefaultSwap_accrualRebate", _wrap_CreditDefaultSwap_accrualRebate, METH_O, "CreditDefaultSwap_accrualRebate(CreditDefaultSwap self) -> ext::shared_ptr< CashFlow >"},
	 { "CreditDefaultSwap_tradeDate", _wrap_CreditDefaultSwap_tradeDate, METH_O, "CreditDefaultSwap_tradeDate(CreditDefaultSwap self) -> Date"},
	 { "CreditDefaultSwap_cashSettlementDays", _wrap_CreditDefaultSwap_cashSettlementDays, METH_O, "CreditDefaultSwap_cashSettlementDays(CreditDefaultSwap self) -> Natural"},
	 { "CreditDefaultSwap_fairUpfront", _wrap_CreditDefaultSwap_fairUpfront, METH_O, "CreditDefaultSwap_fairUpfront(CreditDefaultSwap self) -> Rate"},
	 { "CreditDefaultSwap_fairSpread", _wrap_CreditDefaultSwap_fairSpread, METH_O, "CreditDefaultSwap_fairSpread(CreditDefaultSwap self) -> Rate"},
	 { "CreditDefaultSwap_couponLegBPS", _wrap_CreditDefaultSwap_couponLegBPS, METH_O, "CreditDefaultSwap_couponLegBPS(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_upfrontBPS", _wrap_CreditDefaultSwap_upfrontBPS, METH_O, "CreditDefaultSwap_upfrontBPS(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_couponLegNPV", _wrap_CreditDefaultSwap_couponLegNPV, METH_O, "CreditDefaultSwap_couponLegNPV(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_defaultLegNPV", _wrap_CreditDefaultSwap_defaultLegNPV, METH_O, "CreditDefaultSwap_defaultLegNPV(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_upfrontNPV", _wrap_CreditDefaultSwap_upfrontNPV, METH_O, "CreditDefaultSwap_upfrontNPV(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_accrualRebateNPV", _wrap_CreditDefaultSwap_accrualRebateNPV, METH_O, "CreditDefaultSwap_accrualRebateNPV(CreditDefaultSwap self) -> Real"},
	 { "CreditDefaultSwap_impliedHazardRate", _wrap_CreditDefaultSwap_impliedHazardRate, METH_VARARGS, "CreditDefaultSwap_impliedHazardRate(CreditDefaultSwap self, Real targetNPV, YieldTermStructureHandle discountCurve, DayCounter dayCounter, Real recoveryRate=0.4, Real accuracy=1.0e-6, CreditDefaultSwap::PricingModel model=Midpoint) -> Rate"},
	 { "CreditDefaultSwap_conventionalSpread", _wrap_CreditDefaultSwap_conventionalSpread, METH_VARARGS, "CreditDefaultSwap_conventionalSpread(CreditDefaultSwap self, Real conventionalRecovery, YieldTermStructureHandle discountCurve, DayCounter dayCounter, CreditDefaultSwap::PricingModel model=Midpoint) -> Rate"},
	 { "delete_CreditDefaultSwap", _wrap_delete_CreditDefaultSwap, METH_O, "delete_CreditDefaultSwap(CreditDefaultSwap self)"},
	 { "CreditDefaultSwap_swigregister", CreditDefaultSwap_swigregister, METH_O, NULL},
	 { "CreditDefaultSwap_swiginit", CreditDefaultSwap_swiginit, METH_VARARGS, NULL},
	 { "new_MidPointCdsEngine", _wrap_new_MidPointCdsEngine, METH_VARARGS, "new_MidPointCdsEngine(DefaultProbabilityTermStructureHandle probability, Real recoveryRate, YieldTermStructureHandle discountCurve) -> MidPointCdsEngine"},
	 { "delete_MidPointCdsEngine", _wrap_delete_MidPointCdsEngine, METH_O, "delete_MidPointCdsEngine(MidPointCdsEngine self)"},
	 { "MidPointCdsEngine_swigregister", MidPointCdsEngine_swigregister, METH_O, NULL},
	 { "MidPointCdsEngine_swiginit", MidPointCdsEngine_swiginit, METH_VARARGS, NULL},
	 { "new_IntegralCdsEngine", _wrap_new_IntegralCdsEngine, METH_VARARGS, "IntegralCdsEngine(Period integrationStep, DefaultProbabilityTermStructureHandle probability, Real recoveryRate, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows=False)"},
	 { "delete_IntegralCdsEngine", _wrap_delete_IntegralCdsEngine, METH_O, "delete_IntegralCdsEngine(IntegralCdsEngine self)"},
	 { "IntegralCdsEngine_swigregister", IntegralCdsEngine_swigregister, METH_O, NULL},
	 { "IntegralCdsEngine_swiginit", IntegralCdsEngine_swiginit, METH_VARARGS, NULL},
	 { "new_IsdaCdsEngine", _wrap_new_IsdaCdsEngine, METH_VARARGS, "IsdaCdsEngine(DefaultProbabilityTermStructureHandle probability, Real recoveryRate, YieldTermStructureHandle discountCurve, bool includeSettlementDateFlows=False, IsdaCdsEngine::NumericalFix const numericalFix=Taylor, IsdaCdsEngine::AccrualBias const accrualBias=HalfDayBias, IsdaCdsEngine::ForwardsInCouponPeriod const forwardsInCouponPeriod=Piecewise)"},
	 { "delete_IsdaCdsEngine", _wrap_delete_IsdaCdsEngine, METH_O, "delete_IsdaCdsEngine(IsdaCdsEngine self)"},
	 { "IsdaCdsEngine_swigregister", IsdaCdsEngine_swigregister, METH_O, NULL},
	 { "IsdaCdsEngine_swiginit", IsdaCdsEngine_swiginit, METH_VARARGS, NULL},
	 { "new_CdsOption", _wrap_new_CdsOption, METH_VARARGS, "CdsOption(ext::shared_ptr< CreditDefaultSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, bool knocksOut=True)"},
	 { "CdsOption_atmRate", _wrap_CdsOption_atmRate, METH_O, "CdsOption_atmRate(CdsOption self) -> Rate"},
	 { "CdsOption_riskyAnnuity", _wrap_CdsOption_riskyAnnuity, METH_O, "CdsOption_riskyAnnuity(CdsOption self) -> Real"},
	 { "CdsOption_impliedVolatility", _wrap_CdsOption_impliedVolatility, METH_VARARGS, "CdsOption_impliedVolatility(CdsOption self, Real price, YieldTermStructureHandle termStructure, DefaultProbabilityTermStructureHandle arg4, Real recoveryRate, Real accuracy=1.e-4, Size maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0) -> Volatility"},
	 { "delete_CdsOption", _wrap_delete_CdsOption, METH_O, "delete_CdsOption(CdsOption self)"},
	 { "CdsOption_swigregister", CdsOption_swigregister, METH_O, NULL},
	 { "CdsOption_swiginit", CdsOption_swiginit, METH_VARARGS, NULL},
	 { "new_BlackCdsOptionEngine", _wrap_new_BlackCdsOptionEngine, METH_VARARGS, "new_BlackCdsOptionEngine(DefaultProbabilityTermStructureHandle arg1, Real recoveryRate, YieldTermStructureHandle termStructure, QuoteHandle vol) -> BlackCdsOptionEngine"},
	 { "BlackCdsOptionEngine_termStructure", _wrap_BlackCdsOptionEngine_termStructure, METH_O, "BlackCdsOptionEngine_termStructure(BlackCdsOptionEngine self) -> YieldTermStructureHandle"},
	 { "BlackCdsOptionEngine_volatility", _wrap_BlackCdsOptionEngine_volatility, METH_O, "BlackCdsOptionEngine_volatility(BlackCdsOptionEngine self) -> QuoteHandle"},
	 { "delete_BlackCdsOptionEngine", _wrap_delete_BlackCdsOptionEngine, METH_O, "delete_BlackCdsOptionEngine(BlackCdsOptionEngine self)"},
	 { "BlackCdsOptionEngine_swigregister", BlackCdsOptionEngine_swigregister, METH_O, NULL},
	 { "BlackCdsOptionEngine_swiginit", BlackCdsOptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_DiscountCurve", _wrap_new_DiscountCurve, METH_VARARGS, "DiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), LogLinear i=LogLinear())"},
	 { "DiscountCurve_times", _wrap_DiscountCurve_times, METH_O, "DiscountCurve_times(DiscountCurve self) -> DoubleVector"},
	 { "DiscountCurve_data", _wrap_DiscountCurve_data, METH_O, "DiscountCurve_data(DiscountCurve self) -> DoubleVector"},
	 { "DiscountCurve_dates", _wrap_DiscountCurve_dates, METH_O, "DiscountCurve_dates(DiscountCurve self) -> DateVector"},
	 { "DiscountCurve_discounts", _wrap_DiscountCurve_discounts, METH_O, "DiscountCurve_discounts(DiscountCurve self) -> DoubleVector"},
	 { "DiscountCurve_nodes", _wrap_DiscountCurve_nodes, METH_O, "DiscountCurve_nodes(DiscountCurve self) -> NodeVector"},
	 { "delete_DiscountCurve", _wrap_delete_DiscountCurve, METH_O, "delete_DiscountCurve(DiscountCurve self)"},
	 { "DiscountCurve_swigregister", DiscountCurve_swigregister, METH_O, NULL},
	 { "DiscountCurve_swiginit", DiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicLogCubicDiscountCurve", _wrap_new_MonotonicLogCubicDiscountCurve, METH_VARARGS, "MonotonicLogCubicDiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), MonotonicLogCubic i=MonotonicLogCubic())"},
	 { "MonotonicLogCubicDiscountCurve_times", _wrap_MonotonicLogCubicDiscountCurve_times, METH_O, "MonotonicLogCubicDiscountCurve_times(MonotonicLogCubicDiscountCurve self) -> DoubleVector"},
	 { "MonotonicLogCubicDiscountCurve_data", _wrap_MonotonicLogCubicDiscountCurve_data, METH_O, "MonotonicLogCubicDiscountCurve_data(MonotonicLogCubicDiscountCurve self) -> DoubleVector"},
	 { "MonotonicLogCubicDiscountCurve_dates", _wrap_MonotonicLogCubicDiscountCurve_dates, METH_O, "MonotonicLogCubicDiscountCurve_dates(MonotonicLogCubicDiscountCurve self) -> DateVector"},
	 { "MonotonicLogCubicDiscountCurve_discounts", _wrap_MonotonicLogCubicDiscountCurve_discounts, METH_O, "MonotonicLogCubicDiscountCurve_discounts(MonotonicLogCubicDiscountCurve self) -> DoubleVector"},
	 { "MonotonicLogCubicDiscountCurve_nodes", _wrap_MonotonicLogCubicDiscountCurve_nodes, METH_O, "MonotonicLogCubicDiscountCurve_nodes(MonotonicLogCubicDiscountCurve self) -> NodeVector"},
	 { "delete_MonotonicLogCubicDiscountCurve", _wrap_delete_MonotonicLogCubicDiscountCurve, METH_O, "delete_MonotonicLogCubicDiscountCurve(MonotonicLogCubicDiscountCurve self)"},
	 { "MonotonicLogCubicDiscountCurve_swigregister", MonotonicLogCubicDiscountCurve_swigregister, METH_O, NULL},
	 { "MonotonicLogCubicDiscountCurve_swiginit", MonotonicLogCubicDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NaturalCubicDiscountCurve", _wrap_new_NaturalCubicDiscountCurve, METH_VARARGS, "NaturalCubicDiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), SplineCubic i=SplineCubic())"},
	 { "NaturalCubicDiscountCurve_times", _wrap_NaturalCubicDiscountCurve_times, METH_O, "NaturalCubicDiscountCurve_times(NaturalCubicDiscountCurve self) -> DoubleVector"},
	 { "NaturalCubicDiscountCurve_data", _wrap_NaturalCubicDiscountCurve_data, METH_O, "NaturalCubicDiscountCurve_data(NaturalCubicDiscountCurve self) -> DoubleVector"},
	 { "NaturalCubicDiscountCurve_dates", _wrap_NaturalCubicDiscountCurve_dates, METH_O, "NaturalCubicDiscountCurve_dates(NaturalCubicDiscountCurve self) -> DateVector"},
	 { "NaturalCubicDiscountCurve_discounts", _wrap_NaturalCubicDiscountCurve_discounts, METH_O, "NaturalCubicDiscountCurve_discounts(NaturalCubicDiscountCurve self) -> DoubleVector"},
	 { "NaturalCubicDiscountCurve_nodes", _wrap_NaturalCubicDiscountCurve_nodes, METH_O, "NaturalCubicDiscountCurve_nodes(NaturalCubicDiscountCurve self) -> NodeVector"},
	 { "delete_NaturalCubicDiscountCurve", _wrap_delete_NaturalCubicDiscountCurve, METH_O, "delete_NaturalCubicDiscountCurve(NaturalCubicDiscountCurve self)"},
	 { "NaturalCubicDiscountCurve_swigregister", NaturalCubicDiscountCurve_swigregister, METH_O, NULL},
	 { "NaturalCubicDiscountCurve_swiginit", NaturalCubicDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerLogDiscountCurve", _wrap_new_KrugerLogDiscountCurve, METH_VARARGS, "KrugerLogDiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), KrugerLog i=KrugerLog())"},
	 { "KrugerLogDiscountCurve_times", _wrap_KrugerLogDiscountCurve_times, METH_O, "KrugerLogDiscountCurve_times(KrugerLogDiscountCurve self) -> DoubleVector"},
	 { "KrugerLogDiscountCurve_data", _wrap_KrugerLogDiscountCurve_data, METH_O, "KrugerLogDiscountCurve_data(KrugerLogDiscountCurve self) -> DoubleVector"},
	 { "KrugerLogDiscountCurve_dates", _wrap_KrugerLogDiscountCurve_dates, METH_O, "KrugerLogDiscountCurve_dates(KrugerLogDiscountCurve self) -> DateVector"},
	 { "KrugerLogDiscountCurve_discounts", _wrap_KrugerLogDiscountCurve_discounts, METH_O, "KrugerLogDiscountCurve_discounts(KrugerLogDiscountCurve self) -> DoubleVector"},
	 { "KrugerLogDiscountCurve_nodes", _wrap_KrugerLogDiscountCurve_nodes, METH_O, "KrugerLogDiscountCurve_nodes(KrugerLogDiscountCurve self) -> NodeVector"},
	 { "delete_KrugerLogDiscountCurve", _wrap_delete_KrugerLogDiscountCurve, METH_O, "delete_KrugerLogDiscountCurve(KrugerLogDiscountCurve self)"},
	 { "KrugerLogDiscountCurve_swigregister", KrugerLogDiscountCurve_swigregister, METH_O, NULL},
	 { "KrugerLogDiscountCurve_swiginit", KrugerLogDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NaturalLogCubicDiscountCurve", _wrap_new_NaturalLogCubicDiscountCurve, METH_VARARGS, "NaturalLogCubicDiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), SplineLogCubic i=SplineLogCubic())"},
	 { "NaturalLogCubicDiscountCurve_times", _wrap_NaturalLogCubicDiscountCurve_times, METH_O, "NaturalLogCubicDiscountCurve_times(NaturalLogCubicDiscountCurve self) -> DoubleVector"},
	 { "NaturalLogCubicDiscountCurve_data", _wrap_NaturalLogCubicDiscountCurve_data, METH_O, "NaturalLogCubicDiscountCurve_data(NaturalLogCubicDiscountCurve self) -> DoubleVector"},
	 { "NaturalLogCubicDiscountCurve_dates", _wrap_NaturalLogCubicDiscountCurve_dates, METH_O, "NaturalLogCubicDiscountCurve_dates(NaturalLogCubicDiscountCurve self) -> DateVector"},
	 { "NaturalLogCubicDiscountCurve_discounts", _wrap_NaturalLogCubicDiscountCurve_discounts, METH_O, "NaturalLogCubicDiscountCurve_discounts(NaturalLogCubicDiscountCurve self) -> DoubleVector"},
	 { "NaturalLogCubicDiscountCurve_nodes", _wrap_NaturalLogCubicDiscountCurve_nodes, METH_O, "NaturalLogCubicDiscountCurve_nodes(NaturalLogCubicDiscountCurve self) -> NodeVector"},
	 { "delete_NaturalLogCubicDiscountCurve", _wrap_delete_NaturalLogCubicDiscountCurve, METH_O, "delete_NaturalLogCubicDiscountCurve(NaturalLogCubicDiscountCurve self)"},
	 { "NaturalLogCubicDiscountCurve_swigregister", NaturalLogCubicDiscountCurve_swigregister, METH_O, NULL},
	 { "NaturalLogCubicDiscountCurve_swiginit", NaturalLogCubicDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_LogMixedLinearCubicDiscountCurve", _wrap_new_LogMixedLinearCubicDiscountCurve, METH_VARARGS, "LogMixedLinearCubicDiscountCurve(DateVector dates, DoubleVector discounts, DayCounter dayCounter, Calendar calendar=Calendar(), LogMixedLinearCubic i=LogMixedLinearCubic())"},
	 { "LogMixedLinearCubicDiscountCurve_times", _wrap_LogMixedLinearCubicDiscountCurve_times, METH_O, "LogMixedLinearCubicDiscountCurve_times(LogMixedLinearCubicDiscountCurve self) -> DoubleVector"},
	 { "LogMixedLinearCubicDiscountCurve_data", _wrap_LogMixedLinearCubicDiscountCurve_data, METH_O, "LogMixedLinearCubicDiscountCurve_data(LogMixedLinearCubicDiscountCurve self) -> DoubleVector"},
	 { "LogMixedLinearCubicDiscountCurve_dates", _wrap_LogMixedLinearCubicDiscountCurve_dates, METH_O, "LogMixedLinearCubicDiscountCurve_dates(LogMixedLinearCubicDiscountCurve self) -> DateVector"},
	 { "LogMixedLinearCubicDiscountCurve_discounts", _wrap_LogMixedLinearCubicDiscountCurve_discounts, METH_O, "LogMixedLinearCubicDiscountCurve_discounts(LogMixedLinearCubicDiscountCurve self) -> DoubleVector"},
	 { "LogMixedLinearCubicDiscountCurve_nodes", _wrap_LogMixedLinearCubicDiscountCurve_nodes, METH_O, "LogMixedLinearCubicDiscountCurve_nodes(LogMixedLinearCubicDiscountCurve self) -> NodeVector"},
	 { "delete_LogMixedLinearCubicDiscountCurve", _wrap_delete_LogMixedLinearCubicDiscountCurve, METH_O, "delete_LogMixedLinearCubicDiscountCurve(LogMixedLinearCubicDiscountCurve self)"},
	 { "LogMixedLinearCubicDiscountCurve_swigregister", LogMixedLinearCubicDiscountCurve_swigregister, METH_O, NULL},
	 { "LogMixedLinearCubicDiscountCurve_swiginit", LogMixedLinearCubicDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NormalDistribution", _wrap_new_NormalDistribution, METH_VARARGS, "NormalDistribution(Real average=0.0, Real sigma=1.0)"},
	 { "NormalDistribution___call__", _wrap_NormalDistribution___call__, METH_VARARGS, "NormalDistribution___call__(NormalDistribution self, Real x) -> Real"},
	 { "NormalDistribution_derivative", _wrap_NormalDistribution_derivative, METH_VARARGS, "NormalDistribution_derivative(NormalDistribution self, Real x) -> Real"},
	 { "delete_NormalDistribution", _wrap_delete_NormalDistribution, METH_O, "delete_NormalDistribution(NormalDistribution self)"},
	 { "NormalDistribution_swigregister", NormalDistribution_swigregister, METH_O, NULL},
	 { "NormalDistribution_swiginit", NormalDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeNormalDistribution", _wrap_new_CumulativeNormalDistribution, METH_VARARGS, "CumulativeNormalDistribution(Real average=0.0, Real sigma=1.0)"},
	 { "CumulativeNormalDistribution___call__", _wrap_CumulativeNormalDistribution___call__, METH_VARARGS, "CumulativeNormalDistribution___call__(CumulativeNormalDistribution self, Real x) -> Real"},
	 { "CumulativeNormalDistribution_derivative", _wrap_CumulativeNormalDistribution_derivative, METH_VARARGS, "CumulativeNormalDistribution_derivative(CumulativeNormalDistribution self, Real x) -> Real"},
	 { "delete_CumulativeNormalDistribution", _wrap_delete_CumulativeNormalDistribution, METH_O, "delete_CumulativeNormalDistribution(CumulativeNormalDistribution self)"},
	 { "CumulativeNormalDistribution_swigregister", CumulativeNormalDistribution_swigregister, METH_O, NULL},
	 { "CumulativeNormalDistribution_swiginit", CumulativeNormalDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseCumulativeNormal", _wrap_new_InverseCumulativeNormal, METH_VARARGS, "InverseCumulativeNormal(Real average=0.0, Real sigma=1.0)"},
	 { "InverseCumulativeNormal___call__", _wrap_InverseCumulativeNormal___call__, METH_VARARGS, "InverseCumulativeNormal___call__(InverseCumulativeNormal self, Real x) -> Real"},
	 { "delete_InverseCumulativeNormal", _wrap_delete_InverseCumulativeNormal, METH_O, "delete_InverseCumulativeNormal(InverseCumulativeNormal self)"},
	 { "InverseCumulativeNormal_swigregister", InverseCumulativeNormal_swigregister, METH_O, NULL},
	 { "InverseCumulativeNormal_swiginit", InverseCumulativeNormal_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInverseCumulativeNormal", _wrap_new_MoroInverseCumulativeNormal, METH_VARARGS, "MoroInverseCumulativeNormal(Real average=0.0, Real sigma=1.0)"},
	 { "MoroInverseCumulativeNormal___call__", _wrap_MoroInverseCumulativeNormal___call__, METH_VARARGS, "MoroInverseCumulativeNormal___call__(MoroInverseCumulativeNormal self, Real x) -> Real"},
	 { "delete_MoroInverseCumulativeNormal", _wrap_delete_MoroInverseCumulativeNormal, METH_O, "delete_MoroInverseCumulativeNormal(MoroInverseCumulativeNormal self)"},
	 { "MoroInverseCumulativeNormal_swigregister", MoroInverseCumulativeNormal_swigregister, METH_O, NULL},
	 { "MoroInverseCumulativeNormal_swiginit", MoroInverseCumulativeNormal_swiginit, METH_VARARGS, NULL},
	 { "new_BivariateCumulativeNormalDistribution", _wrap_new_BivariateCumulativeNormalDistribution, METH_O, "new_BivariateCumulativeNormalDistribution(Real rho) -> BivariateCumulativeNormalDistribution"},
	 { "BivariateCumulativeNormalDistribution___call__", _wrap_BivariateCumulativeNormalDistribution___call__, METH_VARARGS, "BivariateCumulativeNormalDistribution___call__(BivariateCumulativeNormalDistribution self, Real x, Real y) -> Real"},
	 { "delete_BivariateCumulativeNormalDistribution", _wrap_delete_BivariateCumulativeNormalDistribution, METH_O, "delete_BivariateCumulativeNormalDistribution(BivariateCumulativeNormalDistribution self)"},
	 { "BivariateCumulativeNormalDistribution_swigregister", BivariateCumulativeNormalDistribution_swigregister, METH_O, NULL},
	 { "BivariateCumulativeNormalDistribution_swiginit", BivariateCumulativeNormalDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_BinomialDistribution", _wrap_new_BinomialDistribution, METH_VARARGS, "new_BinomialDistribution(Real p, BigNatural n) -> BinomialDistribution"},
	 { "BinomialDistribution___call__", _wrap_BinomialDistribution___call__, METH_VARARGS, "BinomialDistribution___call__(BinomialDistribution self, BigNatural k) -> Real"},
	 { "delete_BinomialDistribution", _wrap_delete_BinomialDistribution, METH_O, "delete_BinomialDistribution(BinomialDistribution self)"},
	 { "BinomialDistribution_swigregister", BinomialDistribution_swigregister, METH_O, NULL},
	 { "BinomialDistribution_swiginit", BinomialDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeBinomialDistribution", _wrap_new_CumulativeBinomialDistribution, METH_VARARGS, "new_CumulativeBinomialDistribution(Real p, BigNatural n) -> CumulativeBinomialDistribution"},
	 { "CumulativeBinomialDistribution___call__", _wrap_CumulativeBinomialDistribution___call__, METH_VARARGS, "CumulativeBinomialDistribution___call__(CumulativeBinomialDistribution self, BigNatural k) -> Real"},
	 { "delete_CumulativeBinomialDistribution", _wrap_delete_CumulativeBinomialDistribution, METH_O, "delete_CumulativeBinomialDistribution(CumulativeBinomialDistribution self)"},
	 { "CumulativeBinomialDistribution_swigregister", CumulativeBinomialDistribution_swigregister, METH_O, NULL},
	 { "CumulativeBinomialDistribution_swiginit", CumulativeBinomialDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_BivariateCumulativeNormalDistributionDr78", _wrap_new_BivariateCumulativeNormalDistributionDr78, METH_O, "new_BivariateCumulativeNormalDistributionDr78(Real rho) -> BivariateCumulativeNormalDistributionDr78"},
	 { "BivariateCumulativeNormalDistributionDr78___call__", _wrap_BivariateCumulativeNormalDistributionDr78___call__, METH_VARARGS, "BivariateCumulativeNormalDistributionDr78___call__(BivariateCumulativeNormalDistributionDr78 self, Real a, Real b) -> Real"},
	 { "delete_BivariateCumulativeNormalDistributionDr78", _wrap_delete_BivariateCumulativeNormalDistributionDr78, METH_O, "delete_BivariateCumulativeNormalDistributionDr78(BivariateCumulativeNormalDistributionDr78 self)"},
	 { "BivariateCumulativeNormalDistributionDr78_swigregister", BivariateCumulativeNormalDistributionDr78_swigregister, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionDr78_swiginit", BivariateCumulativeNormalDistributionDr78_swiginit, METH_VARARGS, NULL},
	 { "new_BivariateCumulativeNormalDistributionWe04DP", _wrap_new_BivariateCumulativeNormalDistributionWe04DP, METH_O, "new_BivariateCumulativeNormalDistributionWe04DP(Real rho) -> BivariateCumulativeNormalDistributionWe04DP"},
	 { "BivariateCumulativeNormalDistributionWe04DP___call__", _wrap_BivariateCumulativeNormalDistributionWe04DP___call__, METH_VARARGS, "BivariateCumulativeNormalDistributionWe04DP___call__(BivariateCumulativeNormalDistributionWe04DP self, Real a, Real b) -> Real"},
	 { "delete_BivariateCumulativeNormalDistributionWe04DP", _wrap_delete_BivariateCumulativeNormalDistributionWe04DP, METH_O, "delete_BivariateCumulativeNormalDistributionWe04DP(BivariateCumulativeNormalDistributionWe04DP self)"},
	 { "BivariateCumulativeNormalDistributionWe04DP_swigregister", BivariateCumulativeNormalDistributionWe04DP_swigregister, METH_O, NULL},
	 { "BivariateCumulativeNormalDistributionWe04DP_swiginit", BivariateCumulativeNormalDistributionWe04DP_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeChiSquareDistribution", _wrap_new_CumulativeChiSquareDistribution, METH_O, "new_CumulativeChiSquareDistribution(Real df) -> CumulativeChiSquareDistribution"},
	 { "CumulativeChiSquareDistribution___call__", _wrap_CumulativeChiSquareDistribution___call__, METH_VARARGS, "CumulativeChiSquareDistribution___call__(CumulativeChiSquareDistribution self, Real x) -> Real"},
	 { "delete_CumulativeChiSquareDistribution", _wrap_delete_CumulativeChiSquareDistribution, METH_O, "delete_CumulativeChiSquareDistribution(CumulativeChiSquareDistribution self)"},
	 { "CumulativeChiSquareDistribution_swigregister", CumulativeChiSquareDistribution_swigregister, METH_O, NULL},
	 { "CumulativeChiSquareDistribution_swiginit", CumulativeChiSquareDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_NonCentralCumulativeChiSquareDistribution", _wrap_new_NonCentralCumulativeChiSquareDistribution, METH_VARARGS, "new_NonCentralCumulativeChiSquareDistribution(Real df, Real ncp) -> NonCentralCumulativeChiSquareDistribution"},
	 { "NonCentralCumulativeChiSquareDistribution___call__", _wrap_NonCentralCumulativeChiSquareDistribution___call__, METH_VARARGS, "NonCentralCumulativeChiSquareDistribution___call__(NonCentralCumulativeChiSquareDistribution self, Real x) -> Real"},
	 { "delete_NonCentralCumulativeChiSquareDistribution", _wrap_delete_NonCentralCumulativeChiSquareDistribution, METH_O, "delete_NonCentralCumulativeChiSquareDistribution(NonCentralCumulativeChiSquareDistribution self)"},
	 { "NonCentralCumulativeChiSquareDistribution_swigregister", NonCentralCumulativeChiSquareDistribution_swigregister, METH_O, NULL},
	 { "NonCentralCumulativeChiSquareDistribution_swiginit", NonCentralCumulativeChiSquareDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseNonCentralCumulativeChiSquareDistribution", _wrap_new_InverseNonCentralCumulativeChiSquareDistribution, METH_VARARGS, "InverseNonCentralCumulativeChiSquareDistribution(Real df, Real ncp, Size maxEvaluations=10, Real accuracy=1e-8)"},
	 { "InverseNonCentralCumulativeChiSquareDistribution___call__", _wrap_InverseNonCentralCumulativeChiSquareDistribution___call__, METH_VARARGS, "InverseNonCentralCumulativeChiSquareDistribution___call__(InverseNonCentralCumulativeChiSquareDistribution self, Real x) -> Real"},
	 { "delete_InverseNonCentralCumulativeChiSquareDistribution", _wrap_delete_InverseNonCentralCumulativeChiSquareDistribution, METH_O, "delete_InverseNonCentralCumulativeChiSquareDistribution(InverseNonCentralCumulativeChiSquareDistribution self)"},
	 { "InverseNonCentralCumulativeChiSquareDistribution_swigregister", InverseNonCentralCumulativeChiSquareDistribution_swigregister, METH_O, NULL},
	 { "InverseNonCentralCumulativeChiSquareDistribution_swiginit", InverseNonCentralCumulativeChiSquareDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeGammaDistribution", _wrap_new_CumulativeGammaDistribution, METH_O, "new_CumulativeGammaDistribution(Real a) -> CumulativeGammaDistribution"},
	 { "CumulativeGammaDistribution___call__", _wrap_CumulativeGammaDistribution___call__, METH_VARARGS, "CumulativeGammaDistribution___call__(CumulativeGammaDistribution self, Real x) -> Real"},
	 { "delete_CumulativeGammaDistribution", _wrap_delete_CumulativeGammaDistribution, METH_O, "delete_CumulativeGammaDistribution(CumulativeGammaDistribution self)"},
	 { "CumulativeGammaDistribution_swigregister", CumulativeGammaDistribution_swigregister, METH_O, NULL},
	 { "CumulativeGammaDistribution_swiginit", CumulativeGammaDistribution_swiginit, METH_VARARGS, NULL},
	 { "GammaFunction_logValue", _wrap_GammaFunction_logValue, METH_VARARGS, "GammaFunction_logValue(GammaFunction self, Real x) -> Real"},
	 { "new_GammaFunction", _wrap_new_GammaFunction, METH_NOARGS, "new_GammaFunction() -> GammaFunction"},
	 { "delete_GammaFunction", _wrap_delete_GammaFunction, METH_O, "delete_GammaFunction(GammaFunction self)"},
	 { "GammaFunction_swigregister", GammaFunction_swigregister, METH_O, NULL},
	 { "GammaFunction_swiginit", GammaFunction_swiginit, METH_VARARGS, NULL},
	 { "new_PoissonDistribution", _wrap_new_PoissonDistribution, METH_O, "new_PoissonDistribution(Real mu) -> PoissonDistribution"},
	 { "PoissonDistribution___call__", _wrap_PoissonDistribution___call__, METH_VARARGS, "PoissonDistribution___call__(PoissonDistribution self, BigNatural k) -> Real"},
	 { "delete_PoissonDistribution", _wrap_delete_PoissonDistribution, METH_O, "delete_PoissonDistribution(PoissonDistribution self)"},
	 { "PoissonDistribution_swigregister", PoissonDistribution_swigregister, METH_O, NULL},
	 { "PoissonDistribution_swiginit", PoissonDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativePoissonDistribution", _wrap_new_CumulativePoissonDistribution, METH_O, "new_CumulativePoissonDistribution(Real mu) -> CumulativePoissonDistribution"},
	 { "CumulativePoissonDistribution___call__", _wrap_CumulativePoissonDistribution___call__, METH_VARARGS, "CumulativePoissonDistribution___call__(CumulativePoissonDistribution self, BigNatural k) -> Real"},
	 { "delete_CumulativePoissonDistribution", _wrap_delete_CumulativePoissonDistribution, METH_O, "delete_CumulativePoissonDistribution(CumulativePoissonDistribution self)"},
	 { "CumulativePoissonDistribution_swigregister", CumulativePoissonDistribution_swigregister, METH_O, NULL},
	 { "CumulativePoissonDistribution_swiginit", CumulativePoissonDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseCumulativePoisson", _wrap_new_InverseCumulativePoisson, METH_O, "new_InverseCumulativePoisson(Real lambda_parameter) -> InverseCumulativePoisson"},
	 { "InverseCumulativePoisson___call__", _wrap_InverseCumulativePoisson___call__, METH_VARARGS, "InverseCumulativePoisson___call__(InverseCumulativePoisson self, Real x) -> Real"},
	 { "delete_InverseCumulativePoisson", _wrap_delete_InverseCumulativePoisson, METH_O, "delete_InverseCumulativePoisson(InverseCumulativePoisson self)"},
	 { "InverseCumulativePoisson_swigregister", InverseCumulativePoisson_swigregister, METH_O, NULL},
	 { "InverseCumulativePoisson_swiginit", InverseCumulativePoisson_swiginit, METH_VARARGS, NULL},
	 { "new_StudentDistribution", _wrap_new_StudentDistribution, METH_O, "new_StudentDistribution(Integer n) -> StudentDistribution"},
	 { "StudentDistribution___call__", _wrap_StudentDistribution___call__, METH_VARARGS, "StudentDistribution___call__(StudentDistribution self, Real x) -> Real"},
	 { "delete_StudentDistribution", _wrap_delete_StudentDistribution, METH_O, "delete_StudentDistribution(StudentDistribution self)"},
	 { "StudentDistribution_swigregister", StudentDistribution_swigregister, METH_O, NULL},
	 { "StudentDistribution_swiginit", StudentDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_CumulativeStudentDistribution", _wrap_new_CumulativeStudentDistribution, METH_O, "new_CumulativeStudentDistribution(Integer n) -> CumulativeStudentDistribution"},
	 { "CumulativeStudentDistribution___call__", _wrap_CumulativeStudentDistribution___call__, METH_VARARGS, "CumulativeStudentDistribution___call__(CumulativeStudentDistribution self, Real x) -> Real"},
	 { "delete_CumulativeStudentDistribution", _wrap_delete_CumulativeStudentDistribution, METH_O, "delete_CumulativeStudentDistribution(CumulativeStudentDistribution self)"},
	 { "CumulativeStudentDistribution_swigregister", CumulativeStudentDistribution_swigregister, METH_O, NULL},
	 { "CumulativeStudentDistribution_swiginit", CumulativeStudentDistribution_swiginit, METH_VARARGS, NULL},
	 { "new_InverseCumulativeStudent", _wrap_new_InverseCumulativeStudent, METH_VARARGS, "InverseCumulativeStudent(Integer n, Real accuracy=1e-6, Size maxIterations=50)"},
	 { "InverseCumulativeStudent___call__", _wrap_InverseCumulativeStudent___call__, METH_VARARGS, "InverseCumulativeStudent___call__(InverseCumulativeStudent self, Real x) -> Real"},
	 { "delete_InverseCumulativeStudent", _wrap_delete_InverseCumulativeStudent, METH_O, "delete_InverseCumulativeStudent(InverseCumulativeStudent self)"},
	 { "InverseCumulativeStudent_swigregister", InverseCumulativeStudent_swigregister, METH_O, NULL},
	 { "InverseCumulativeStudent_swiginit", InverseCumulativeStudent_swiginit, METH_VARARGS, NULL},
	 { "new_Money", _wrap_new_Money, METH_VARARGS, "\n"
		"Money(Currency currency, Decimal value)\n"
		"new_Money(Decimal value, Currency currency) -> Money\n"
		""},
	 { "Money_currency", _wrap_Money_currency, METH_O, "Money_currency(Money self) -> Currency"},
	 { "Money_value", _wrap_Money_value, METH_O, "Money_value(Money self) -> Decimal"},
	 { "Money_rounded", _wrap_Money_rounded, METH_O, "Money_rounded(Money self) -> Money"},
	 { "Money___pos__", _wrap_Money___pos__, METH_O, "Money___pos__(Money self) -> Money"},
	 { "Money___neg__", _wrap_Money___neg__, METH_O, "Money___neg__(Money self) -> Money"},
	 { "Money___add__", _wrap_Money___add__, METH_VARARGS, "Money___add__(Money self, Money m) -> Money"},
	 { "Money___sub__", _wrap_Money___sub__, METH_VARARGS, "Money___sub__(Money self, Money m) -> Money"},
	 { "Money___mul__", _wrap_Money___mul__, METH_VARARGS, "Money___mul__(Money self, Decimal x) -> Money"},
	 { "Money___truediv__", _wrap_Money___truediv__, METH_VARARGS, "\n"
		"Money___truediv__(Money self, Decimal x) -> Money\n"
		"Money___truediv__(Money self, Money m) -> Decimal\n"
		""},
	 { "Money___rmul__", _wrap_Money___rmul__, METH_VARARGS, "Money___rmul__(Money self, Decimal x) -> Money"},
	 { "Money___lt__", _wrap_Money___lt__, METH_VARARGS, "Money___lt__(Money self, Money other) -> bool"},
	 { "Money___gt__", _wrap_Money___gt__, METH_VARARGS, "Money___gt__(Money self, Money other) -> bool"},
	 { "Money___le__", _wrap_Money___le__, METH_VARARGS, "Money___le__(Money self, Money other) -> bool"},
	 { "Money___ge__", _wrap_Money___ge__, METH_VARARGS, "Money___ge__(Money self, Money other) -> bool"},
	 { "Money___cmp__", _wrap_Money___cmp__, METH_VARARGS, "Money___cmp__(Money self, Money other) -> int"},
	 { "Money___str__", _wrap_Money___str__, METH_O, "Money___str__(Money self) -> std::string"},
	 { "Money_setConversionType", _wrap_Money_setConversionType, METH_O, "Money_setConversionType(Money::ConversionType type)"},
	 { "Money_setBaseCurrency", _wrap_Money_setBaseCurrency, METH_O, "Money_setBaseCurrency(Currency c)"},
	 { "delete_Money", _wrap_delete_Money, METH_O, "delete_Money(Money self)"},
	 { "Money_swigregister", Money_swigregister, METH_O, NULL},
	 { "Money_swiginit", Money_swiginit, METH_VARARGS, NULL},
	 { "new_ExchangeRate", _wrap_new_ExchangeRate, METH_VARARGS, "new_ExchangeRate(Currency source, Currency target, Decimal rate) -> ExchangeRate"},
	 { "ExchangeRate_source", _wrap_ExchangeRate_source, METH_O, "ExchangeRate_source(ExchangeRate self) -> Currency"},
	 { "ExchangeRate_target", _wrap_ExchangeRate_target, METH_O, "ExchangeRate_target(ExchangeRate self) -> Currency"},
	 { "ExchangeRate_type", _wrap_ExchangeRate_type, METH_O, "ExchangeRate_type(ExchangeRate self) -> ExchangeRate::Type"},
	 { "ExchangeRate_rate", _wrap_ExchangeRate_rate, METH_O, "ExchangeRate_rate(ExchangeRate self) -> Decimal"},
	 { "ExchangeRate_exchange", _wrap_ExchangeRate_exchange, METH_VARARGS, "ExchangeRate_exchange(ExchangeRate self, Money amount) -> Money"},
	 { "ExchangeRate_chain", _wrap_ExchangeRate_chain, METH_VARARGS, "ExchangeRate_chain(ExchangeRate r1, ExchangeRate r2) -> ExchangeRate"},
	 { "delete_ExchangeRate", _wrap_delete_ExchangeRate, METH_O, "delete_ExchangeRate(ExchangeRate self)"},
	 { "ExchangeRate_swigregister", ExchangeRate_swigregister, METH_O, NULL},
	 { "ExchangeRate_swiginit", ExchangeRate_swiginit, METH_VARARGS, NULL},
	 { "ExchangeRateManager_instance", _wrap_ExchangeRateManager_instance, METH_NOARGS, "ExchangeRateManager_instance() -> ExchangeRateManager"},
	 { "ExchangeRateManager_add", _wrap_ExchangeRateManager_add, METH_VARARGS, "ExchangeRateManager_add(ExchangeRateManager self, ExchangeRate arg2, Date startDate=Date::minDate(), Date endDate=Date::maxDate())"},
	 { "ExchangeRateManager_lookup", _wrap_ExchangeRateManager_lookup, METH_VARARGS, "ExchangeRateManager_lookup(ExchangeRateManager self, Currency source, Currency target, Date date, ExchangeRate::Type type=Derived) -> ExchangeRate"},
	 { "ExchangeRateManager_clear", _wrap_ExchangeRateManager_clear, METH_O, "ExchangeRateManager_clear(ExchangeRateManager self)"},
	 { "delete_ExchangeRateManager", _wrap_delete_ExchangeRateManager, METH_O, "delete_ExchangeRateManager(ExchangeRateManager self)"},
	 { "ExchangeRateManager_swigregister", ExchangeRateManager_swigregister, METH_O, NULL},
	 { "Settings_instance", _wrap_Settings_instance, METH_NOARGS, "Settings_instance() -> Settings"},
	 { "Settings_getEvaluationDate", _wrap_Settings_getEvaluationDate, METH_O, "Settings_getEvaluationDate(Settings self) -> Date"},
	 { "Settings_setEvaluationDate", _wrap_Settings_setEvaluationDate, METH_VARARGS, "Settings_setEvaluationDate(Settings self, Date d)"},
	 { "Settings_includeReferenceDateEvents", _wrap_Settings_includeReferenceDateEvents, METH_VARARGS, "Settings_includeReferenceDateEvents(Settings self, bool b)"},
	 { "Settings_includeTodaysCashFlows", _wrap_Settings_includeTodaysCashFlows, METH_VARARGS, "Settings_includeTodaysCashFlows(Settings self, bool b)"},
	 { "Settings_setEnforcesTodaysHistoricFixings", _wrap_Settings_setEnforcesTodaysHistoricFixings, METH_VARARGS, "Settings_setEnforcesTodaysHistoricFixings(Settings self, bool b)"},
	 { "Settings_getEnforcesTodaysHistoricFixings", _wrap_Settings_getEnforcesTodaysHistoricFixings, METH_O, "Settings_getEnforcesTodaysHistoricFixings(Settings self) -> bool"},
	 { "delete_Settings", _wrap_delete_Settings, METH_O, "delete_Settings(Settings self)"},
	 { "Settings_swigregister", Settings_swigregister, METH_O, NULL},
	 { "new_Fdm1dMesher", _wrap_new_Fdm1dMesher, METH_O, "new_Fdm1dMesher(Size size) -> Fdm1dMesher"},
	 { "Fdm1dMesher_size", _wrap_Fdm1dMesher_size, METH_O, "Fdm1dMesher_size(Fdm1dMesher self) -> Size"},
	 { "Fdm1dMesher_dplus", _wrap_Fdm1dMesher_dplus, METH_VARARGS, "Fdm1dMesher_dplus(Fdm1dMesher self, Size index) -> Real"},
	 { "Fdm1dMesher_dminus", _wrap_Fdm1dMesher_dminus, METH_VARARGS, "Fdm1dMesher_dminus(Fdm1dMesher self, Size index) -> Real"},
	 { "Fdm1dMesher_location", _wrap_Fdm1dMesher_location, METH_VARARGS, "Fdm1dMesher_location(Fdm1dMesher self, Size index) -> Real"},
	 { "Fdm1dMesher_locations", _wrap_Fdm1dMesher_locations, METH_O, "Fdm1dMesher_locations(Fdm1dMesher self) -> DoubleVector"},
	 { "delete_Fdm1dMesher", _wrap_delete_Fdm1dMesher, METH_O, "delete_Fdm1dMesher(Fdm1dMesher self)"},
	 { "Fdm1dMesher_swigregister", Fdm1dMesher_swigregister, METH_O, NULL},
	 { "Fdm1dMesher_swiginit", Fdm1dMesher_swiginit, METH_VARARGS, NULL},
	 { "Fdm1dMesherVector_iterator", _wrap_Fdm1dMesherVector_iterator, METH_O, "Fdm1dMesherVector_iterator(Fdm1dMesherVector self) -> SwigPyIterator"},
	 { "Fdm1dMesherVector___nonzero__", _wrap_Fdm1dMesherVector___nonzero__, METH_O, "Fdm1dMesherVector___nonzero__(Fdm1dMesherVector self) -> bool"},
	 { "Fdm1dMesherVector___bool__", _wrap_Fdm1dMesherVector___bool__, METH_O, "Fdm1dMesherVector___bool__(Fdm1dMesherVector self) -> bool"},
	 { "Fdm1dMesherVector___len__", _wrap_Fdm1dMesherVector___len__, METH_O, "Fdm1dMesherVector___len__(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type"},
	 { "Fdm1dMesherVector___getslice__", _wrap_Fdm1dMesherVector___getslice__, METH_VARARGS, "Fdm1dMesherVector___getslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j) -> Fdm1dMesherVector"},
	 { "Fdm1dMesherVector___setslice__", _wrap_Fdm1dMesherVector___setslice__, METH_VARARGS, "\n"
		"Fdm1dMesherVector___setslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j)\n"
		"Fdm1dMesherVector___setslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j, Fdm1dMesherVector v)\n"
		""},
	 { "Fdm1dMesherVector___delslice__", _wrap_Fdm1dMesherVector___delslice__, METH_VARARGS, "Fdm1dMesherVector___delslice__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type j)"},
	 { "Fdm1dMesherVector___delitem__", _wrap_Fdm1dMesherVector___delitem__, METH_VARARGS, "\n"
		"Fdm1dMesherVector___delitem__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i)\n"
		"Fdm1dMesherVector___delitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "Fdm1dMesherVector___getitem__", _wrap_Fdm1dMesherVector___getitem__, METH_VARARGS, "\n"
		"Fdm1dMesherVector___getitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice) -> Fdm1dMesherVector\n"
		"Fdm1dMesherVector___getitem__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &\n"
		""},
	 { "Fdm1dMesherVector___setitem__", _wrap_Fdm1dMesherVector___setitem__, METH_VARARGS, "\n"
		"Fdm1dMesherVector___setitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice, Fdm1dMesherVector v)\n"
		"Fdm1dMesherVector___setitem__(Fdm1dMesherVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"Fdm1dMesherVector___setitem__(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::difference_type i, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)\n"
		""},
	 { "Fdm1dMesherVector_pop", _wrap_Fdm1dMesherVector_pop, METH_O, "Fdm1dMesherVector_pop(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type"},
	 { "Fdm1dMesherVector_append", _wrap_Fdm1dMesherVector_append, METH_VARARGS, "Fdm1dMesherVector_append(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)"},
	 { "Fdm1dMesherVector_empty", _wrap_Fdm1dMesherVector_empty, METH_O, "Fdm1dMesherVector_empty(Fdm1dMesherVector self) -> bool"},
	 { "Fdm1dMesherVector_size", _wrap_Fdm1dMesherVector_size, METH_O, "Fdm1dMesherVector_size(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type"},
	 { "Fdm1dMesherVector_swap", _wrap_Fdm1dMesherVector_swap, METH_VARARGS, "Fdm1dMesherVector_swap(Fdm1dMesherVector self, Fdm1dMesherVector v)"},
	 { "Fdm1dMesherVector_begin", _wrap_Fdm1dMesherVector_begin, METH_O, "Fdm1dMesherVector_begin(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator"},
	 { "Fdm1dMesherVector_end", _wrap_Fdm1dMesherVector_end, METH_O, "Fdm1dMesherVector_end(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator"},
	 { "Fdm1dMesherVector_rbegin", _wrap_Fdm1dMesherVector_rbegin, METH_O, "Fdm1dMesherVector_rbegin(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator"},
	 { "Fdm1dMesherVector_rend", _wrap_Fdm1dMesherVector_rend, METH_O, "Fdm1dMesherVector_rend(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::reverse_iterator"},
	 { "Fdm1dMesherVector_clear", _wrap_Fdm1dMesherVector_clear, METH_O, "Fdm1dMesherVector_clear(Fdm1dMesherVector self)"},
	 { "Fdm1dMesherVector_get_allocator", _wrap_Fdm1dMesherVector_get_allocator, METH_O, "Fdm1dMesherVector_get_allocator(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::allocator_type"},
	 { "Fdm1dMesherVector_pop_back", _wrap_Fdm1dMesherVector_pop_back, METH_O, "Fdm1dMesherVector_pop_back(Fdm1dMesherVector self)"},
	 { "Fdm1dMesherVector_erase", _wrap_Fdm1dMesherVector_erase, METH_VARARGS, "\n"
		"Fdm1dMesherVector_erase(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator\n"
		"Fdm1dMesherVector_erase(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator first, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator last) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator\n"
		""},
	 { "new_Fdm1dMesherVector", _wrap_new_Fdm1dMesherVector, METH_VARARGS, "\n"
		"Fdm1dMesherVector()\n"
		"Fdm1dMesherVector(Fdm1dMesherVector other)\n"
		"Fdm1dMesherVector(std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type size)\n"
		"new_Fdm1dMesherVector(std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type size, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & value) -> Fdm1dMesherVector\n"
		""},
	 { "Fdm1dMesherVector_push_back", _wrap_Fdm1dMesherVector_push_back, METH_VARARGS, "Fdm1dMesherVector_push_back(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)"},
	 { "Fdm1dMesherVector_front", _wrap_Fdm1dMesherVector_front, METH_O, "Fdm1dMesherVector_front(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &"},
	 { "Fdm1dMesherVector_back", _wrap_Fdm1dMesherVector_back, METH_O, "Fdm1dMesherVector_back(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const &"},
	 { "Fdm1dMesherVector_assign", _wrap_Fdm1dMesherVector_assign, METH_VARARGS, "Fdm1dMesherVector_assign(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)"},
	 { "Fdm1dMesherVector_resize", _wrap_Fdm1dMesherVector_resize, METH_VARARGS, "\n"
		"Fdm1dMesherVector_resize(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type new_size)\n"
		"Fdm1dMesherVector_resize(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type new_size, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)\n"
		""},
	 { "Fdm1dMesherVector_insert", _wrap_Fdm1dMesherVector_insert, METH_VARARGS, "\n"
		"Fdm1dMesherVector_insert(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator\n"
		"Fdm1dMesherVector_insert(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::iterator pos, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n, std::vector< ext::shared_ptr< Fdm1dMesher > >::value_type const & x)\n"
		""},
	 { "Fdm1dMesherVector_reserve", _wrap_Fdm1dMesherVector_reserve, METH_VARARGS, "Fdm1dMesherVector_reserve(Fdm1dMesherVector self, std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type n)"},
	 { "Fdm1dMesherVector_capacity", _wrap_Fdm1dMesherVector_capacity, METH_O, "Fdm1dMesherVector_capacity(Fdm1dMesherVector self) -> std::vector< ext::shared_ptr< Fdm1dMesher > >::size_type"},
	 { "delete_Fdm1dMesherVector", _wrap_delete_Fdm1dMesherVector, METH_O, "delete_Fdm1dMesherVector(Fdm1dMesherVector self)"},
	 { "Fdm1dMesherVector_swigregister", Fdm1dMesherVector_swigregister, METH_O, NULL},
	 { "Fdm1dMesherVector_swiginit", Fdm1dMesherVector_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBlackScholesMesher", (PyCFunction)(void(*)(void))_wrap_new_FdmBlackScholesMesher, METH_VARARGS|METH_KEYWORDS, "new_FdmBlackScholesMesher(Size size, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Time maturity, Real strike, doubleOrNull xMinConstraint=Null< Real >(), doubleOrNull xMaxConstraint=Null< Real >(), Real eps=0.0001, Real scaleFactor=1.5, DoublePair cPoint=(std::pair< Real,Real >(Null<Real>(), Null<Real>())), DividendSchedule dividendSchedule=std::vector< ext::shared_ptr< Dividend > >(), ext::shared_ptr< FdmQuantoHelper > const & fdmQuantoHelper=ext::shared_ptr< FdmQuantoHelper >(), Real spotAdjustment=0.0) -> FdmBlackScholesMesher"},
	 { "FdmBlackScholesMesher_processHelper", _wrap_FdmBlackScholesMesher_processHelper, METH_VARARGS, "FdmBlackScholesMesher_processHelper(QuoteHandle s0, YieldTermStructureHandle rTS, YieldTermStructureHandle qTS, Volatility vol) -> ext::shared_ptr< GeneralizedBlackScholesProcess >"},
	 { "delete_FdmBlackScholesMesher", _wrap_delete_FdmBlackScholesMesher, METH_O, "delete_FdmBlackScholesMesher(FdmBlackScholesMesher self)"},
	 { "FdmBlackScholesMesher_swigregister", FdmBlackScholesMesher_swigregister, METH_O, NULL},
	 { "FdmBlackScholesMesher_swiginit", FdmBlackScholesMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Concentrating1dMesherPoint", _wrap_new_Concentrating1dMesherPoint, METH_VARARGS, "new_Concentrating1dMesherPoint(double arg1, double arg2, bool arg3) -> Concentrating1dMesherPoint"},
	 { "Concentrating1dMesherPoint_first", _wrap_Concentrating1dMesherPoint_first, METH_O, "Concentrating1dMesherPoint_first(Concentrating1dMesherPoint self) -> double"},
	 { "Concentrating1dMesherPoint_second", _wrap_Concentrating1dMesherPoint_second, METH_O, "Concentrating1dMesherPoint_second(Concentrating1dMesherPoint self) -> double"},
	 { "Concentrating1dMesherPoint_third", _wrap_Concentrating1dMesherPoint_third, METH_O, "Concentrating1dMesherPoint_third(Concentrating1dMesherPoint self) -> bool"},
	 { "delete_Concentrating1dMesherPoint", _wrap_delete_Concentrating1dMesherPoint, METH_O, "delete_Concentrating1dMesherPoint(Concentrating1dMesherPoint self)"},
	 { "Concentrating1dMesherPoint_swigregister", Concentrating1dMesherPoint_swigregister, METH_O, NULL},
	 { "Concentrating1dMesherPoint_swiginit", Concentrating1dMesherPoint_swiginit, METH_VARARGS, NULL},
	 { "Concentrating1dMesherPointVector_iterator", _wrap_Concentrating1dMesherPointVector_iterator, METH_O, "Concentrating1dMesherPointVector_iterator(Concentrating1dMesherPointVector self) -> SwigPyIterator"},
	 { "Concentrating1dMesherPointVector___nonzero__", _wrap_Concentrating1dMesherPointVector___nonzero__, METH_O, "Concentrating1dMesherPointVector___nonzero__(Concentrating1dMesherPointVector self) -> bool"},
	 { "Concentrating1dMesherPointVector___bool__", _wrap_Concentrating1dMesherPointVector___bool__, METH_O, "Concentrating1dMesherPointVector___bool__(Concentrating1dMesherPointVector self) -> bool"},
	 { "Concentrating1dMesherPointVector___len__", _wrap_Concentrating1dMesherPointVector___len__, METH_O, "Concentrating1dMesherPointVector___len__(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::size_type"},
	 { "Concentrating1dMesherPointVector___getslice__", _wrap_Concentrating1dMesherPointVector___getslice__, METH_VARARGS, "Concentrating1dMesherPointVector___getslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j) -> Concentrating1dMesherPointVector"},
	 { "Concentrating1dMesherPointVector___setslice__", _wrap_Concentrating1dMesherPointVector___setslice__, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector___setslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j)\n"
		"Concentrating1dMesherPointVector___setslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j, Concentrating1dMesherPointVector v)\n"
		""},
	 { "Concentrating1dMesherPointVector___delslice__", _wrap_Concentrating1dMesherPointVector___delslice__, METH_VARARGS, "Concentrating1dMesherPointVector___delslice__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, std::vector< ext::tuple< double,double,bool > >::difference_type j)"},
	 { "Concentrating1dMesherPointVector___delitem__", _wrap_Concentrating1dMesherPointVector___delitem__, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector___delitem__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i)\n"
		"Concentrating1dMesherPointVector___delitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "Concentrating1dMesherPointVector___getitem__", _wrap_Concentrating1dMesherPointVector___getitem__, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector___getitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice) -> Concentrating1dMesherPointVector\n"
		"Concentrating1dMesherPointVector___getitem__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i) -> Concentrating1dMesherPoint\n"
		""},
	 { "Concentrating1dMesherPointVector___setitem__", _wrap_Concentrating1dMesherPointVector___setitem__, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector___setitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice, Concentrating1dMesherPointVector v)\n"
		"Concentrating1dMesherPointVector___setitem__(Concentrating1dMesherPointVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"Concentrating1dMesherPointVector___setitem__(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::difference_type i, Concentrating1dMesherPoint x)\n"
		""},
	 { "Concentrating1dMesherPointVector_pop", _wrap_Concentrating1dMesherPointVector_pop, METH_O, "Concentrating1dMesherPointVector_pop(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPoint"},
	 { "Concentrating1dMesherPointVector_append", _wrap_Concentrating1dMesherPointVector_append, METH_VARARGS, "Concentrating1dMesherPointVector_append(Concentrating1dMesherPointVector self, Concentrating1dMesherPoint x)"},
	 { "Concentrating1dMesherPointVector_empty", _wrap_Concentrating1dMesherPointVector_empty, METH_O, "Concentrating1dMesherPointVector_empty(Concentrating1dMesherPointVector self) -> bool"},
	 { "Concentrating1dMesherPointVector_size", _wrap_Concentrating1dMesherPointVector_size, METH_O, "Concentrating1dMesherPointVector_size(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::size_type"},
	 { "Concentrating1dMesherPointVector_swap", _wrap_Concentrating1dMesherPointVector_swap, METH_VARARGS, "Concentrating1dMesherPointVector_swap(Concentrating1dMesherPointVector self, Concentrating1dMesherPointVector v)"},
	 { "Concentrating1dMesherPointVector_begin", _wrap_Concentrating1dMesherPointVector_begin, METH_O, "Concentrating1dMesherPointVector_begin(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::iterator"},
	 { "Concentrating1dMesherPointVector_end", _wrap_Concentrating1dMesherPointVector_end, METH_O, "Concentrating1dMesherPointVector_end(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::iterator"},
	 { "Concentrating1dMesherPointVector_rbegin", _wrap_Concentrating1dMesherPointVector_rbegin, METH_O, "Concentrating1dMesherPointVector_rbegin(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::reverse_iterator"},
	 { "Concentrating1dMesherPointVector_rend", _wrap_Concentrating1dMesherPointVector_rend, METH_O, "Concentrating1dMesherPointVector_rend(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::reverse_iterator"},
	 { "Concentrating1dMesherPointVector_clear", _wrap_Concentrating1dMesherPointVector_clear, METH_O, "Concentrating1dMesherPointVector_clear(Concentrating1dMesherPointVector self)"},
	 { "Concentrating1dMesherPointVector_get_allocator", _wrap_Concentrating1dMesherPointVector_get_allocator, METH_O, "Concentrating1dMesherPointVector_get_allocator(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::allocator_type"},
	 { "Concentrating1dMesherPointVector_pop_back", _wrap_Concentrating1dMesherPointVector_pop_back, METH_O, "Concentrating1dMesherPointVector_pop_back(Concentrating1dMesherPointVector self)"},
	 { "Concentrating1dMesherPointVector_erase", _wrap_Concentrating1dMesherPointVector_erase, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector_erase(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator pos) -> std::vector< ext::tuple< double,double,bool > >::iterator\n"
		"Concentrating1dMesherPointVector_erase(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator first, std::vector< ext::tuple< double,double,bool > >::iterator last) -> std::vector< ext::tuple< double,double,bool > >::iterator\n"
		""},
	 { "new_Concentrating1dMesherPointVector", _wrap_new_Concentrating1dMesherPointVector, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector()\n"
		"Concentrating1dMesherPointVector(Concentrating1dMesherPointVector other)\n"
		"Concentrating1dMesherPointVector(std::vector< ext::tuple< double,double,bool > >::size_type size)\n"
		"new_Concentrating1dMesherPointVector(std::vector< ext::tuple< double,double,bool > >::size_type size, Concentrating1dMesherPoint value) -> Concentrating1dMesherPointVector\n"
		""},
	 { "Concentrating1dMesherPointVector_push_back", _wrap_Concentrating1dMesherPointVector_push_back, METH_VARARGS, "Concentrating1dMesherPointVector_push_back(Concentrating1dMesherPointVector self, Concentrating1dMesherPoint x)"},
	 { "Concentrating1dMesherPointVector_front", _wrap_Concentrating1dMesherPointVector_front, METH_O, "Concentrating1dMesherPointVector_front(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPoint"},
	 { "Concentrating1dMesherPointVector_back", _wrap_Concentrating1dMesherPointVector_back, METH_O, "Concentrating1dMesherPointVector_back(Concentrating1dMesherPointVector self) -> Concentrating1dMesherPoint"},
	 { "Concentrating1dMesherPointVector_assign", _wrap_Concentrating1dMesherPointVector_assign, METH_VARARGS, "Concentrating1dMesherPointVector_assign(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type n, Concentrating1dMesherPoint x)"},
	 { "Concentrating1dMesherPointVector_resize", _wrap_Concentrating1dMesherPointVector_resize, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector_resize(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type new_size)\n"
		"Concentrating1dMesherPointVector_resize(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type new_size, Concentrating1dMesherPoint x)\n"
		""},
	 { "Concentrating1dMesherPointVector_insert", _wrap_Concentrating1dMesherPointVector_insert, METH_VARARGS, "\n"
		"Concentrating1dMesherPointVector_insert(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator pos, Concentrating1dMesherPoint x) -> std::vector< ext::tuple< double,double,bool > >::iterator\n"
		"Concentrating1dMesherPointVector_insert(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::iterator pos, std::vector< ext::tuple< double,double,bool > >::size_type n, Concentrating1dMesherPoint x)\n"
		""},
	 { "Concentrating1dMesherPointVector_reserve", _wrap_Concentrating1dMesherPointVector_reserve, METH_VARARGS, "Concentrating1dMesherPointVector_reserve(Concentrating1dMesherPointVector self, std::vector< ext::tuple< double,double,bool > >::size_type n)"},
	 { "Concentrating1dMesherPointVector_capacity", _wrap_Concentrating1dMesherPointVector_capacity, METH_O, "Concentrating1dMesherPointVector_capacity(Concentrating1dMesherPointVector self) -> std::vector< ext::tuple< double,double,bool > >::size_type"},
	 { "delete_Concentrating1dMesherPointVector", _wrap_delete_Concentrating1dMesherPointVector, METH_O, "delete_Concentrating1dMesherPointVector(Concentrating1dMesherPointVector self)"},
	 { "Concentrating1dMesherPointVector_swigregister", Concentrating1dMesherPointVector_swigregister, METH_O, NULL},
	 { "Concentrating1dMesherPointVector_swiginit", Concentrating1dMesherPointVector_swiginit, METH_VARARGS, NULL},
	 { "new_Concentrating1dMesher", _wrap_new_Concentrating1dMesher, METH_VARARGS, "\n"
		"Concentrating1dMesher(Real start, Real end, Size size, DoublePair cPoints=(std::pair< Real,Real >(Null<Real>(), Null<Real>())), bool const requireCPoint=False)\n"
		"Concentrating1dMesher(Real start, Real end, Size size, Concentrating1dMesherPointVector cPoints, Real tol=1e-8)\n"
		""},
	 { "delete_Concentrating1dMesher", _wrap_delete_Concentrating1dMesher, METH_O, "delete_Concentrating1dMesher(Concentrating1dMesher self)"},
	 { "Concentrating1dMesher_swigregister", Concentrating1dMesher_swigregister, METH_O, NULL},
	 { "Concentrating1dMesher_swiginit", Concentrating1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_ExponentialJump1dMesher", _wrap_new_ExponentialJump1dMesher, METH_VARARGS, "ExponentialJump1dMesher(Size steps, Real beta, Real jumpIntensity, Real eta, Real eps=1e-3)"},
	 { "delete_ExponentialJump1dMesher", _wrap_delete_ExponentialJump1dMesher, METH_O, "delete_ExponentialJump1dMesher(ExponentialJump1dMesher self)"},
	 { "ExponentialJump1dMesher_swigregister", ExponentialJump1dMesher_swigregister, METH_O, NULL},
	 { "ExponentialJump1dMesher_swiginit", ExponentialJump1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmCEV1dMesher", (PyCFunction)(void(*)(void))_wrap_new_FdmCEV1dMesher, METH_VARARGS|METH_KEYWORDS, "new_FdmCEV1dMesher(Size size, Real f0, Real alpha, Real beta, Time maturity, Real eps=0.0001, Real scaleFactor=1.5, DoublePair cPoint=(std::pair< Real,Real >(Null<Real>(), Null<Real>()))) -> FdmCEV1dMesher"},
	 { "delete_FdmCEV1dMesher", _wrap_delete_FdmCEV1dMesher, METH_O, "delete_FdmCEV1dMesher(FdmCEV1dMesher self)"},
	 { "FdmCEV1dMesher_swigregister", FdmCEV1dMesher_swigregister, METH_O, NULL},
	 { "FdmCEV1dMesher_swiginit", FdmCEV1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonVarianceMesher", _wrap_new_FdmHestonVarianceMesher, METH_VARARGS, "FdmHestonVarianceMesher(Size size, ext::shared_ptr< HestonProcess > const & process, Time maturity, Size tAvgSteps=10, Real epsilon=0.0001)"},
	 { "FdmHestonVarianceMesher_volaEstimate", _wrap_FdmHestonVarianceMesher_volaEstimate, METH_O, "FdmHestonVarianceMesher_volaEstimate(FdmHestonVarianceMesher self) -> Real"},
	 { "delete_FdmHestonVarianceMesher", _wrap_delete_FdmHestonVarianceMesher, METH_O, "delete_FdmHestonVarianceMesher(FdmHestonVarianceMesher self)"},
	 { "FdmHestonVarianceMesher_swigregister", FdmHestonVarianceMesher_swigregister, METH_O, NULL},
	 { "FdmHestonVarianceMesher_swiginit", FdmHestonVarianceMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonLocalVolatilityVarianceMesher", _wrap_new_FdmHestonLocalVolatilityVarianceMesher, METH_VARARGS, "FdmHestonLocalVolatilityVarianceMesher(Size size, ext::shared_ptr< HestonProcess > const & process, ext::shared_ptr< LocalVolTermStructure > const & leverageFct, Time maturity, Size tAvgSteps=10, Real epsilon=0.0001)"},
	 { "FdmHestonLocalVolatilityVarianceMesher_volaEstimate", _wrap_FdmHestonLocalVolatilityVarianceMesher_volaEstimate, METH_O, "FdmHestonLocalVolatilityVarianceMesher_volaEstimate(FdmHestonLocalVolatilityVarianceMesher self) -> Real"},
	 { "delete_FdmHestonLocalVolatilityVarianceMesher", _wrap_delete_FdmHestonLocalVolatilityVarianceMesher, METH_O, "delete_FdmHestonLocalVolatilityVarianceMesher(FdmHestonLocalVolatilityVarianceMesher self)"},
	 { "FdmHestonLocalVolatilityVarianceMesher_swigregister", FdmHestonLocalVolatilityVarianceMesher_swigregister, METH_O, NULL},
	 { "FdmHestonLocalVolatilityVarianceMesher_swiginit", FdmHestonLocalVolatilityVarianceMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSimpleProcess1dMesher", _wrap_new_FdmSimpleProcess1dMesher, METH_VARARGS, "FdmSimpleProcess1dMesher(Size size, ext::shared_ptr< StochasticProcess1D > const & process, Time maturity, Size tAvgSteps=10, Real epsilon=0.0001, doubleOrNull mandatoryPoint=Null< Real >())"},
	 { "delete_FdmSimpleProcess1dMesher", _wrap_delete_FdmSimpleProcess1dMesher, METH_O, "delete_FdmSimpleProcess1dMesher(FdmSimpleProcess1dMesher self)"},
	 { "FdmSimpleProcess1dMesher_swigregister", FdmSimpleProcess1dMesher_swigregister, METH_O, NULL},
	 { "FdmSimpleProcess1dMesher_swiginit", FdmSimpleProcess1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Uniform1dMesher", _wrap_new_Uniform1dMesher, METH_VARARGS, "new_Uniform1dMesher(Real start, Real end, Size size) -> Uniform1dMesher"},
	 { "delete_Uniform1dMesher", _wrap_delete_Uniform1dMesher, METH_O, "delete_Uniform1dMesher(Uniform1dMesher self)"},
	 { "Uniform1dMesher_swigregister", Uniform1dMesher_swigregister, METH_O, NULL},
	 { "Uniform1dMesher_swiginit", Uniform1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Predefined1dMesher", _wrap_new_Predefined1dMesher, METH_O, "new_Predefined1dMesher(DoubleVector x) -> Predefined1dMesher"},
	 { "delete_Predefined1dMesher", _wrap_delete_Predefined1dMesher, METH_O, "delete_Predefined1dMesher(Predefined1dMesher self)"},
	 { "Predefined1dMesher_swigregister", Predefined1dMesher_swigregister, METH_O, NULL},
	 { "Predefined1dMesher_swiginit", Predefined1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_Glued1dMesher", _wrap_new_Glued1dMesher, METH_VARARGS, "new_Glued1dMesher(Fdm1dMesher leftMesher, Fdm1dMesher rightMesher) -> Glued1dMesher"},
	 { "delete_Glued1dMesher", _wrap_delete_Glued1dMesher, METH_O, "delete_Glued1dMesher(Glued1dMesher self)"},
	 { "Glued1dMesher_swigregister", Glued1dMesher_swigregister, METH_O, NULL},
	 { "Glued1dMesher_swiginit", Glued1dMesher_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLinearOpIterator", _wrap_new_FdmLinearOpIterator, METH_VARARGS, "\n"
		"FdmLinearOpIterator(UnsignedIntVector dim)\n"
		"new_FdmLinearOpIterator(UnsignedIntVector dim, UnsignedIntVector coordinates, Size index) -> FdmLinearOpIterator\n"
		""},
	 { "FdmLinearOpIterator_coordinates", _wrap_FdmLinearOpIterator_coordinates, METH_O, "FdmLinearOpIterator_coordinates(FdmLinearOpIterator self) -> UnsignedIntVector"},
	 { "FdmLinearOpIterator_increment", _wrap_FdmLinearOpIterator_increment, METH_O, "FdmLinearOpIterator_increment(FdmLinearOpIterator self)"},
	 { "FdmLinearOpIterator_notEqual", _wrap_FdmLinearOpIterator_notEqual, METH_VARARGS, "FdmLinearOpIterator_notEqual(FdmLinearOpIterator self, FdmLinearOpIterator iterator) -> bool"},
	 { "FdmLinearOpIterator_index", _wrap_FdmLinearOpIterator_index, METH_O, "FdmLinearOpIterator_index(FdmLinearOpIterator self) -> Size"},
	 { "delete_FdmLinearOpIterator", _wrap_delete_FdmLinearOpIterator, METH_O, "delete_FdmLinearOpIterator(FdmLinearOpIterator self)"},
	 { "FdmLinearOpIterator_swigregister", FdmLinearOpIterator_swigregister, METH_O, NULL},
	 { "FdmLinearOpIterator_swiginit", FdmLinearOpIterator_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLinearOpLayout", _wrap_new_FdmLinearOpLayout, METH_O, "new_FdmLinearOpLayout(UnsignedIntVector dim) -> FdmLinearOpLayout"},
	 { "FdmLinearOpLayout_spacing", _wrap_FdmLinearOpLayout_spacing, METH_O, "FdmLinearOpLayout_spacing(FdmLinearOpLayout self) -> UnsignedIntVector"},
	 { "FdmLinearOpLayout_dim", _wrap_FdmLinearOpLayout_dim, METH_O, "FdmLinearOpLayout_dim(FdmLinearOpLayout self) -> UnsignedIntVector"},
	 { "FdmLinearOpLayout_index", _wrap_FdmLinearOpLayout_index, METH_VARARGS, "FdmLinearOpLayout_index(FdmLinearOpLayout self, UnsignedIntVector coordinates) -> Size"},
	 { "FdmLinearOpLayout_begin", _wrap_FdmLinearOpLayout_begin, METH_O, "FdmLinearOpLayout_begin(FdmLinearOpLayout self) -> FdmLinearOpIterator"},
	 { "FdmLinearOpLayout_end", _wrap_FdmLinearOpLayout_end, METH_O, "FdmLinearOpLayout_end(FdmLinearOpLayout self) -> FdmLinearOpIterator"},
	 { "FdmLinearOpLayout_size", _wrap_FdmLinearOpLayout_size, METH_O, "FdmLinearOpLayout_size(FdmLinearOpLayout self) -> Size"},
	 { "FdmLinearOpLayout_neighbourhood", _wrap_FdmLinearOpLayout_neighbourhood, METH_VARARGS, "\n"
		"FdmLinearOpLayout_neighbourhood(FdmLinearOpLayout self, FdmLinearOpIterator iterator, Size i, Integer offset) -> Size\n"
		"FdmLinearOpLayout_neighbourhood(FdmLinearOpLayout self, FdmLinearOpIterator iterator, Size i1, Integer offset1, Size i2, Integer offset2) -> Size\n"
		""},
	 { "FdmLinearOpLayout_iter_neighbourhood", _wrap_FdmLinearOpLayout_iter_neighbourhood, METH_VARARGS, "FdmLinearOpLayout_iter_neighbourhood(FdmLinearOpLayout self, FdmLinearOpIterator iterator, Size i, Integer offset) -> FdmLinearOpIterator"},
	 { "delete_FdmLinearOpLayout", _wrap_delete_FdmLinearOpLayout, METH_O, "delete_FdmLinearOpLayout(FdmLinearOpLayout self)"},
	 { "FdmLinearOpLayout_swigregister", FdmLinearOpLayout_swigregister, METH_O, NULL},
	 { "FdmLinearOpLayout_swiginit", FdmLinearOpLayout_swiginit, METH_VARARGS, NULL},
	 { "FdmMesher_dplus", _wrap_FdmMesher_dplus, METH_VARARGS, "FdmMesher_dplus(FdmMesher self, FdmLinearOpIterator iter, Size direction) -> Real"},
	 { "FdmMesher_dminus", _wrap_FdmMesher_dminus, METH_VARARGS, "FdmMesher_dminus(FdmMesher self, FdmLinearOpIterator iter, Size direction) -> Real"},
	 { "FdmMesher_location", _wrap_FdmMesher_location, METH_VARARGS, "FdmMesher_location(FdmMesher self, FdmLinearOpIterator iter, Size direction) -> Real"},
	 { "FdmMesher_locations", _wrap_FdmMesher_locations, METH_VARARGS, "FdmMesher_locations(FdmMesher self, Size direction) -> Array"},
	 { "FdmMesher_layout", _wrap_FdmMesher_layout, METH_O, "FdmMesher_layout(FdmMesher self) -> ext::shared_ptr< FdmLinearOpLayout >"},
	 { "delete_FdmMesher", _wrap_delete_FdmMesher, METH_O, "delete_FdmMesher(FdmMesher self)"},
	 { "FdmMesher_swigregister", FdmMesher_swigregister, METH_O, NULL},
	 { "new_FdmMesherComposite", _wrap_new_FdmMesherComposite, METH_VARARGS, "\n"
		"FdmMesherComposite(ext::shared_ptr< FdmLinearOpLayout > const & layout, Fdm1dMesherVector mesher)\n"
		"FdmMesherComposite(Fdm1dMesherVector mesher)\n"
		"FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const & mesher)\n"
		"FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const & m1, ext::shared_ptr< Fdm1dMesher > const & m2)\n"
		"FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const & m1, ext::shared_ptr< Fdm1dMesher > const & m2, ext::shared_ptr< Fdm1dMesher > const & m3)\n"
		"new_FdmMesherComposite(ext::shared_ptr< Fdm1dMesher > const & m1, ext::shared_ptr< Fdm1dMesher > const & m2, ext::shared_ptr< Fdm1dMesher > const & m3, ext::shared_ptr< Fdm1dMesher > const & m4) -> FdmMesherComposite\n"
		""},
	 { "FdmMesherComposite_getFdm1dMeshers", _wrap_FdmMesherComposite_getFdm1dMeshers, METH_O, "FdmMesherComposite_getFdm1dMeshers(FdmMesherComposite self) -> Fdm1dMesherVector"},
	 { "delete_FdmMesherComposite", _wrap_delete_FdmMesherComposite, METH_O, "delete_FdmMesherComposite(FdmMesherComposite self)"},
	 { "FdmMesherComposite_swigregister", FdmMesherComposite_swigregister, METH_O, NULL},
	 { "FdmMesherComposite_swiginit", FdmMesherComposite_swiginit, METH_VARARGS, NULL},
	 { "FdmLinearOp_apply", _wrap_FdmLinearOp_apply, METH_VARARGS, "FdmLinearOp_apply(FdmLinearOp self, Array r) -> Array"},
	 { "delete_FdmLinearOp", _wrap_delete_FdmLinearOp, METH_O, "delete_FdmLinearOp(FdmLinearOp self)"},
	 { "FdmLinearOp_swigregister", FdmLinearOp_swigregister, METH_O, NULL},
	 { "SparseMatrix_row_idx_set", _wrap_SparseMatrix_row_idx_set, METH_VARARGS, "SparseMatrix_row_idx_set(SparseMatrix self, UnsignedIntVector row_idx)"},
	 { "SparseMatrix_row_idx_get", _wrap_SparseMatrix_row_idx_get, METH_O, "SparseMatrix_row_idx_get(SparseMatrix self) -> UnsignedIntVector"},
	 { "SparseMatrix_col_idx_set", _wrap_SparseMatrix_col_idx_set, METH_VARARGS, "SparseMatrix_col_idx_set(SparseMatrix self, UnsignedIntVector col_idx)"},
	 { "SparseMatrix_col_idx_get", _wrap_SparseMatrix_col_idx_get, METH_O, "SparseMatrix_col_idx_get(SparseMatrix self) -> UnsignedIntVector"},
	 { "SparseMatrix_data_set", _wrap_SparseMatrix_data_set, METH_VARARGS, "SparseMatrix_data_set(SparseMatrix self, DoubleVector data)"},
	 { "SparseMatrix_data_get", _wrap_SparseMatrix_data_get, METH_O, "SparseMatrix_data_get(SparseMatrix self) -> DoubleVector"},
	 { "new_SparseMatrix", _wrap_new_SparseMatrix, METH_NOARGS, "new_SparseMatrix() -> SparseMatrix"},
	 { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"},
	 { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL},
	 { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL},
	 { "FdmLinearOpComposite_size", _wrap_FdmLinearOpComposite_size, METH_O, "FdmLinearOpComposite_size(FdmLinearOpComposite self) -> Size"},
	 { "FdmLinearOpComposite_setTime", _wrap_FdmLinearOpComposite_setTime, METH_VARARGS, "FdmLinearOpComposite_setTime(FdmLinearOpComposite self, Time t1, Time t2)"},
	 { "FdmLinearOpComposite_apply_mixed", _wrap_FdmLinearOpComposite_apply_mixed, METH_VARARGS, "FdmLinearOpComposite_apply_mixed(FdmLinearOpComposite self, Array r) -> Array"},
	 { "FdmLinearOpComposite_apply_direction", _wrap_FdmLinearOpComposite_apply_direction, METH_VARARGS, "FdmLinearOpComposite_apply_direction(FdmLinearOpComposite self, Size direction, Array r) -> Array"},
	 { "FdmLinearOpComposite_solve_splitting", _wrap_FdmLinearOpComposite_solve_splitting, METH_VARARGS, "FdmLinearOpComposite_solve_splitting(FdmLinearOpComposite self, Size direction, Array r, Real s) -> Array"},
	 { "FdmLinearOpComposite_preconditioner", _wrap_FdmLinearOpComposite_preconditioner, METH_VARARGS, "FdmLinearOpComposite_preconditioner(FdmLinearOpComposite self, Array r, Real s) -> Array"},
	 { "FdmLinearOpComposite_to_sparse_matrix", _wrap_FdmLinearOpComposite_to_sparse_matrix, METH_O, "FdmLinearOpComposite_to_sparse_matrix(FdmLinearOpComposite self) -> ext::shared_ptr< SparseMatrix >"},
	 { "delete_FdmLinearOpComposite", _wrap_delete_FdmLinearOpComposite, METH_O, "delete_FdmLinearOpComposite(FdmLinearOpComposite self)"},
	 { "FdmLinearOpComposite_swigregister", FdmLinearOpComposite_swigregister, METH_O, NULL},
	 { "new_FdmLinearOpCompositeProxy", _wrap_new_FdmLinearOpCompositeProxy, METH_O, "new_FdmLinearOpCompositeProxy(PyObject * callback) -> FdmLinearOpCompositeProxy"},
	 { "delete_FdmLinearOpCompositeProxy", _wrap_delete_FdmLinearOpCompositeProxy, METH_O, "delete_FdmLinearOpCompositeProxy(FdmLinearOpCompositeProxy self)"},
	 { "FdmLinearOpCompositeProxy_swigregister", FdmLinearOpCompositeProxy_swigregister, METH_O, NULL},
	 { "FdmLinearOpCompositeProxy_swiginit", FdmLinearOpCompositeProxy_swiginit, METH_VARARGS, NULL},
	 { "FdmBoundaryCondition_applyBeforeApplying", _wrap_FdmBoundaryCondition_applyBeforeApplying, METH_VARARGS, "FdmBoundaryCondition_applyBeforeApplying(FdmBoundaryCondition self, FdmLinearOp arg2)"},
	 { "FdmBoundaryCondition_applyAfterApplying", _wrap_FdmBoundaryCondition_applyAfterApplying, METH_VARARGS, "FdmBoundaryCondition_applyAfterApplying(FdmBoundaryCondition self, Array arg2)"},
	 { "FdmBoundaryCondition_applyBeforeSolving", _wrap_FdmBoundaryCondition_applyBeforeSolving, METH_VARARGS, "FdmBoundaryCondition_applyBeforeSolving(FdmBoundaryCondition self, FdmLinearOp arg2, Array rhs)"},
	 { "FdmBoundaryCondition_applyAfterSolving", _wrap_FdmBoundaryCondition_applyAfterSolving, METH_VARARGS, "FdmBoundaryCondition_applyAfterSolving(FdmBoundaryCondition self, Array arg2)"},
	 { "FdmBoundaryCondition_setTime", _wrap_FdmBoundaryCondition_setTime, METH_VARARGS, "FdmBoundaryCondition_setTime(FdmBoundaryCondition self, Time t)"},
	 { "delete_FdmBoundaryCondition", _wrap_delete_FdmBoundaryCondition, METH_O, "delete_FdmBoundaryCondition(FdmBoundaryCondition self)"},
	 { "FdmBoundaryCondition_swigregister", FdmBoundaryCondition_swigregister, METH_O, NULL},
	 { "FdmBoundaryConditionSet_iterator", _wrap_FdmBoundaryConditionSet_iterator, METH_O, "FdmBoundaryConditionSet_iterator(FdmBoundaryConditionSet self) -> SwigPyIterator"},
	 { "FdmBoundaryConditionSet___nonzero__", _wrap_FdmBoundaryConditionSet___nonzero__, METH_O, "FdmBoundaryConditionSet___nonzero__(FdmBoundaryConditionSet self) -> bool"},
	 { "FdmBoundaryConditionSet___bool__", _wrap_FdmBoundaryConditionSet___bool__, METH_O, "FdmBoundaryConditionSet___bool__(FdmBoundaryConditionSet self) -> bool"},
	 { "FdmBoundaryConditionSet___len__", _wrap_FdmBoundaryConditionSet___len__, METH_O, "FdmBoundaryConditionSet___len__(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type"},
	 { "FdmBoundaryConditionSet___getslice__", _wrap_FdmBoundaryConditionSet___getslice__, METH_VARARGS, "FdmBoundaryConditionSet___getslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j) -> FdmBoundaryConditionSet"},
	 { "FdmBoundaryConditionSet___setslice__", _wrap_FdmBoundaryConditionSet___setslice__, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet___setslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j)\n"
		"FdmBoundaryConditionSet___setslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j, FdmBoundaryConditionSet v)\n"
		""},
	 { "FdmBoundaryConditionSet___delslice__", _wrap_FdmBoundaryConditionSet___delslice__, METH_VARARGS, "FdmBoundaryConditionSet___delslice__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type j)"},
	 { "FdmBoundaryConditionSet___delitem__", _wrap_FdmBoundaryConditionSet___delitem__, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet___delitem__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i)\n"
		"FdmBoundaryConditionSet___delitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "FdmBoundaryConditionSet___getitem__", _wrap_FdmBoundaryConditionSet___getitem__, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet___getitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice) -> FdmBoundaryConditionSet\n"
		"FdmBoundaryConditionSet___getitem__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &\n"
		""},
	 { "FdmBoundaryConditionSet___setitem__", _wrap_FdmBoundaryConditionSet___setitem__, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet___setitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice, FdmBoundaryConditionSet v)\n"
		"FdmBoundaryConditionSet___setitem__(FdmBoundaryConditionSet self, SWIGPY_SLICEOBJECT * slice)\n"
		"FdmBoundaryConditionSet___setitem__(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::difference_type i, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)\n"
		""},
	 { "FdmBoundaryConditionSet_pop", _wrap_FdmBoundaryConditionSet_pop, METH_O, "FdmBoundaryConditionSet_pop(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type"},
	 { "FdmBoundaryConditionSet_append", _wrap_FdmBoundaryConditionSet_append, METH_VARARGS, "FdmBoundaryConditionSet_append(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)"},
	 { "FdmBoundaryConditionSet_empty", _wrap_FdmBoundaryConditionSet_empty, METH_O, "FdmBoundaryConditionSet_empty(FdmBoundaryConditionSet self) -> bool"},
	 { "FdmBoundaryConditionSet_size", _wrap_FdmBoundaryConditionSet_size, METH_O, "FdmBoundaryConditionSet_size(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type"},
	 { "FdmBoundaryConditionSet_swap", _wrap_FdmBoundaryConditionSet_swap, METH_VARARGS, "FdmBoundaryConditionSet_swap(FdmBoundaryConditionSet self, FdmBoundaryConditionSet v)"},
	 { "FdmBoundaryConditionSet_begin", _wrap_FdmBoundaryConditionSet_begin, METH_O, "FdmBoundaryConditionSet_begin(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator"},
	 { "FdmBoundaryConditionSet_end", _wrap_FdmBoundaryConditionSet_end, METH_O, "FdmBoundaryConditionSet_end(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator"},
	 { "FdmBoundaryConditionSet_rbegin", _wrap_FdmBoundaryConditionSet_rbegin, METH_O, "FdmBoundaryConditionSet_rbegin(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator"},
	 { "FdmBoundaryConditionSet_rend", _wrap_FdmBoundaryConditionSet_rend, METH_O, "FdmBoundaryConditionSet_rend(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::reverse_iterator"},
	 { "FdmBoundaryConditionSet_clear", _wrap_FdmBoundaryConditionSet_clear, METH_O, "FdmBoundaryConditionSet_clear(FdmBoundaryConditionSet self)"},
	 { "FdmBoundaryConditionSet_get_allocator", _wrap_FdmBoundaryConditionSet_get_allocator, METH_O, "FdmBoundaryConditionSet_get_allocator(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::allocator_type"},
	 { "FdmBoundaryConditionSet_pop_back", _wrap_FdmBoundaryConditionSet_pop_back, METH_O, "FdmBoundaryConditionSet_pop_back(FdmBoundaryConditionSet self)"},
	 { "FdmBoundaryConditionSet_erase", _wrap_FdmBoundaryConditionSet_erase, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet_erase(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator\n"
		"FdmBoundaryConditionSet_erase(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator first, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator last) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator\n"
		""},
	 { "new_FdmBoundaryConditionSet", _wrap_new_FdmBoundaryConditionSet, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet()\n"
		"FdmBoundaryConditionSet(FdmBoundaryConditionSet other)\n"
		"FdmBoundaryConditionSet(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type size)\n"
		"new_FdmBoundaryConditionSet(std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type size, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & value) -> FdmBoundaryConditionSet\n"
		""},
	 { "FdmBoundaryConditionSet_push_back", _wrap_FdmBoundaryConditionSet_push_back, METH_VARARGS, "FdmBoundaryConditionSet_push_back(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)"},
	 { "FdmBoundaryConditionSet_front", _wrap_FdmBoundaryConditionSet_front, METH_O, "FdmBoundaryConditionSet_front(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &"},
	 { "FdmBoundaryConditionSet_back", _wrap_FdmBoundaryConditionSet_back, METH_O, "FdmBoundaryConditionSet_back(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const &"},
	 { "FdmBoundaryConditionSet_assign", _wrap_FdmBoundaryConditionSet_assign, METH_VARARGS, "FdmBoundaryConditionSet_assign(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)"},
	 { "FdmBoundaryConditionSet_resize", _wrap_FdmBoundaryConditionSet_resize, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet_resize(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type new_size)\n"
		"FdmBoundaryConditionSet_resize(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type new_size, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)\n"
		""},
	 { "FdmBoundaryConditionSet_insert", _wrap_FdmBoundaryConditionSet_insert, METH_VARARGS, "\n"
		"FdmBoundaryConditionSet_insert(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator\n"
		"FdmBoundaryConditionSet_insert(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::iterator pos, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::value_type const & x)\n"
		""},
	 { "FdmBoundaryConditionSet_reserve", _wrap_FdmBoundaryConditionSet_reserve, METH_VARARGS, "FdmBoundaryConditionSet_reserve(FdmBoundaryConditionSet self, std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type n)"},
	 { "FdmBoundaryConditionSet_capacity", _wrap_FdmBoundaryConditionSet_capacity, METH_O, "FdmBoundaryConditionSet_capacity(FdmBoundaryConditionSet self) -> std::vector< ext::shared_ptr< FdmBoundaryCondition > >::size_type"},
	 { "delete_FdmBoundaryConditionSet", _wrap_delete_FdmBoundaryConditionSet, METH_O, "delete_FdmBoundaryConditionSet(FdmBoundaryConditionSet self)"},
	 { "FdmBoundaryConditionSet_swigregister", FdmBoundaryConditionSet_swigregister, METH_O, NULL},
	 { "FdmBoundaryConditionSet_swiginit", FdmBoundaryConditionSet_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDirichletBoundary", _wrap_new_FdmDirichletBoundary, METH_VARARGS, "new_FdmDirichletBoundary(ext::shared_ptr< FdmMesher > const & mesher, Real valueOnBoundary, Size direction, FdmDirichletBoundary::Side side) -> FdmDirichletBoundary"},
	 { "FdmDirichletBoundary_applyAfterApplying", _wrap_FdmDirichletBoundary_applyAfterApplying, METH_VARARGS, "\n"
		"FdmDirichletBoundary_applyAfterApplying(FdmDirichletBoundary self, Array arg2)\n"
		"FdmDirichletBoundary_applyAfterApplying(FdmDirichletBoundary self, Real x, Real value) -> Real\n"
		""},
	 { "delete_FdmDirichletBoundary", _wrap_delete_FdmDirichletBoundary, METH_O, "delete_FdmDirichletBoundary(FdmDirichletBoundary self)"},
	 { "FdmDirichletBoundary_swigregister", FdmDirichletBoundary_swigregister, METH_O, NULL},
	 { "FdmDirichletBoundary_swiginit", FdmDirichletBoundary_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDiscountDirichletBoundary", _wrap_new_FdmDiscountDirichletBoundary, METH_VARARGS, "new_FdmDiscountDirichletBoundary(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< YieldTermStructure > const & rTS, Time maturityTime, Real valueOnBoundary, Size direction, FdmDiscountDirichletBoundary::Side side) -> FdmDiscountDirichletBoundary"},
	 { "delete_FdmDiscountDirichletBoundary", _wrap_delete_FdmDiscountDirichletBoundary, METH_O, "delete_FdmDiscountDirichletBoundary(FdmDiscountDirichletBoundary self)"},
	 { "FdmDiscountDirichletBoundary_swigregister", FdmDiscountDirichletBoundary_swigregister, METH_O, NULL},
	 { "FdmDiscountDirichletBoundary_swiginit", FdmDiscountDirichletBoundary_swiginit, METH_VARARGS, NULL},
	 { "new_FdmTimeDepDirichletBoundary", _wrap_new_FdmTimeDepDirichletBoundary, METH_VARARGS, "new_FdmTimeDepDirichletBoundary(ext::shared_ptr< FdmMesher > const & mesher, PyObject * function, Size direction, FdmTimeDepDirichletBoundary::Side side) -> FdmTimeDepDirichletBoundary"},
	 { "delete_FdmTimeDepDirichletBoundary", _wrap_delete_FdmTimeDepDirichletBoundary, METH_O, "delete_FdmTimeDepDirichletBoundary(FdmTimeDepDirichletBoundary self)"},
	 { "FdmTimeDepDirichletBoundary_swigregister", FdmTimeDepDirichletBoundary_swigregister, METH_O, NULL},
	 { "FdmTimeDepDirichletBoundary_swiginit", FdmTimeDepDirichletBoundary_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBatesOp", _wrap_new_FdmBatesOp, METH_VARARGS, "FdmBatesOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< BatesProcess > const & batesProcess, FdmBoundaryConditionSet bcSet, Size integroIntegrationOrder, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >())"},
	 { "delete_FdmBatesOp", _wrap_delete_FdmBatesOp, METH_O, "delete_FdmBatesOp(FdmBatesOp self)"},
	 { "FdmBatesOp_swigregister", FdmBatesOp_swigregister, METH_O, NULL},
	 { "FdmBatesOp_swiginit", FdmBatesOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBlackScholesOp", _wrap_new_FdmBlackScholesOp, METH_VARARGS, "FdmBlackScholesOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real strike, bool localVol=False, doubleOrNull illegalLocalVolOverwrite=-Null< Real >(), Size direction=0, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >())"},
	 { "delete_FdmBlackScholesOp", _wrap_delete_FdmBlackScholesOp, METH_O, "delete_FdmBlackScholesOp(FdmBlackScholesOp self)"},
	 { "FdmBlackScholesOp_swigregister", FdmBlackScholesOp_swigregister, METH_O, NULL},
	 { "FdmBlackScholesOp_swiginit", FdmBlackScholesOp_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm2dBlackScholesOp", _wrap_new_Fdm2dBlackScholesOp, METH_VARARGS, "Fdm2dBlackScholesOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p2, Real correlation, Time maturity, bool localVol=False, doubleOrNull illegalLocalVolOverwrite=-Null< Real >())"},
	 { "delete_Fdm2dBlackScholesOp", _wrap_delete_Fdm2dBlackScholesOp, METH_O, "delete_Fdm2dBlackScholesOp(Fdm2dBlackScholesOp self)"},
	 { "Fdm2dBlackScholesOp_swigregister", Fdm2dBlackScholesOp_swigregister, METH_O, NULL},
	 { "Fdm2dBlackScholesOp_swiginit", Fdm2dBlackScholesOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmCEVOp", _wrap_new_FdmCEVOp, METH_VARARGS, "new_FdmCEVOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< YieldTermStructure > const & rTS, Real f0, Real alpha, Real beta, Size direction) -> FdmCEVOp"},
	 { "delete_FdmCEVOp", _wrap_delete_FdmCEVOp, METH_O, "delete_FdmCEVOp(FdmCEVOp self)"},
	 { "FdmCEVOp_swigregister", FdmCEVOp_swigregister, METH_O, NULL},
	 { "FdmCEVOp_swiginit", FdmCEVOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmG2Op", _wrap_new_FdmG2Op, METH_VARARGS, "new_FdmG2Op(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< G2 > const & model, Size direction1, Size direction2) -> FdmG2Op"},
	 { "delete_FdmG2Op", _wrap_delete_FdmG2Op, METH_O, "delete_FdmG2Op(FdmG2Op self)"},
	 { "FdmG2Op_swigregister", FdmG2Op_swigregister, METH_O, NULL},
	 { "FdmG2Op_swiginit", FdmG2Op_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonHullWhiteOp", _wrap_new_FdmHestonHullWhiteOp, METH_VARARGS, "new_FdmHestonHullWhiteOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< HullWhiteProcess > const & hwProcess, Real equityShortRateCorrelation) -> FdmHestonHullWhiteOp"},
	 { "delete_FdmHestonHullWhiteOp", _wrap_delete_FdmHestonHullWhiteOp, METH_O, "delete_FdmHestonHullWhiteOp(FdmHestonHullWhiteOp self)"},
	 { "FdmHestonHullWhiteOp_swigregister", FdmHestonHullWhiteOp_swigregister, METH_O, NULL},
	 { "FdmHestonHullWhiteOp_swiginit", FdmHestonHullWhiteOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonOp", _wrap_new_FdmHestonOp, METH_VARARGS, "FdmHestonOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >())"},
	 { "delete_FdmHestonOp", _wrap_delete_FdmHestonOp, METH_O, "delete_FdmHestonOp(FdmHestonOp self)"},
	 { "FdmHestonOp_swigregister", FdmHestonOp_swigregister, METH_O, NULL},
	 { "FdmHestonOp_swiginit", FdmHestonOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHullWhiteOp", _wrap_new_FdmHullWhiteOp, METH_VARARGS, "new_FdmHullWhiteOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HullWhite > const & model, Size direction) -> FdmHullWhiteOp"},
	 { "delete_FdmHullWhiteOp", _wrap_delete_FdmHullWhiteOp, METH_O, "delete_FdmHullWhiteOp(FdmHullWhiteOp self)"},
	 { "FdmHullWhiteOp_swigregister", FdmHullWhiteOp_swigregister, METH_O, NULL},
	 { "FdmHullWhiteOp_swiginit", FdmHullWhiteOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLocalVolFwdOp", _wrap_new_FdmLocalVolFwdOp, METH_VARARGS, "FdmLocalVolFwdOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< Quote > const & spot, ext::shared_ptr< YieldTermStructure > const & rTS, ext::shared_ptr< YieldTermStructure > const & qTS, ext::shared_ptr< LocalVolTermStructure > const & localVol, Size direction=0)"},
	 { "delete_FdmLocalVolFwdOp", _wrap_delete_FdmLocalVolFwdOp, METH_O, "delete_FdmLocalVolFwdOp(FdmLocalVolFwdOp self)"},
	 { "FdmLocalVolFwdOp_swigregister", FdmLocalVolFwdOp_swigregister, METH_O, NULL},
	 { "FdmLocalVolFwdOp_swiginit", FdmLocalVolFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmOrnsteinUhlenbeckOp", _wrap_new_FdmOrnsteinUhlenbeckOp, METH_VARARGS, "FdmOrnsteinUhlenbeckOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< OrnsteinUhlenbeckProcess > const & p, ext::shared_ptr< YieldTermStructure > const & rTS, Size direction=0)"},
	 { "delete_FdmOrnsteinUhlenbeckOp", _wrap_delete_FdmOrnsteinUhlenbeckOp, METH_O, "delete_FdmOrnsteinUhlenbeckOp(FdmOrnsteinUhlenbeckOp self)"},
	 { "FdmOrnsteinUhlenbeckOp_swigregister", FdmOrnsteinUhlenbeckOp_swigregister, METH_O, NULL},
	 { "FdmOrnsteinUhlenbeckOp_swiginit", FdmOrnsteinUhlenbeckOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSabrOp", _wrap_new_FdmSabrOp, METH_VARARGS, "new_FdmSabrOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< YieldTermStructure > const & rTS, Real f0, Real alpha, Real beta, Real nu, Real rho) -> FdmSabrOp"},
	 { "delete_FdmSabrOp", _wrap_delete_FdmSabrOp, METH_O, "delete_FdmSabrOp(FdmSabrOp self)"},
	 { "FdmSabrOp_swigregister", FdmSabrOp_swigregister, METH_O, NULL},
	 { "FdmSabrOp_swiginit", FdmSabrOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmZabrOp", _wrap_new_FdmZabrOp, METH_VARARGS, "new_FdmZabrOp(ext::shared_ptr< FdmMesher > const & mesher, Real const beta, Real const nu, Real const rho, Real const gamma) -> FdmZabrOp"},
	 { "delete_FdmZabrOp", _wrap_delete_FdmZabrOp, METH_O, "delete_FdmZabrOp(FdmZabrOp self)"},
	 { "FdmZabrOp_swigregister", FdmZabrOp_swigregister, METH_O, NULL},
	 { "FdmZabrOp_swiginit", FdmZabrOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDupire1dOp", _wrap_new_FdmDupire1dOp, METH_VARARGS, "new_FdmDupire1dOp(ext::shared_ptr< FdmMesher > const & mesher, Array localVolatility) -> FdmDupire1dOp"},
	 { "delete_FdmDupire1dOp", _wrap_delete_FdmDupire1dOp, METH_O, "delete_FdmDupire1dOp(FdmDupire1dOp self)"},
	 { "FdmDupire1dOp_swigregister", FdmDupire1dOp_swigregister, METH_O, NULL},
	 { "FdmDupire1dOp_swiginit", FdmDupire1dOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBlackScholesFwdOp", _wrap_new_FdmBlackScholesFwdOp, METH_VARARGS, "FdmBlackScholesFwdOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Real strike, bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >(), Size direction=0)"},
	 { "delete_FdmBlackScholesFwdOp", _wrap_delete_FdmBlackScholesFwdOp, METH_O, "delete_FdmBlackScholesFwdOp(FdmBlackScholesFwdOp self)"},
	 { "FdmBlackScholesFwdOp_swigregister", FdmBlackScholesFwdOp_swigregister, METH_O, NULL},
	 { "FdmBlackScholesFwdOp_swiginit", FdmBlackScholesFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSquareRootFwdOp", _wrap_new_FdmSquareRootFwdOp, METH_VARARGS, "FdmSquareRootFwdOp(ext::shared_ptr< FdmMesher > const & mesher, Real kappa, Real theta, Real sigma, Size direction, FdmSquareRootFwdOp::TransformationType type=Plain)"},
	 { "delete_FdmSquareRootFwdOp", _wrap_delete_FdmSquareRootFwdOp, METH_O, "delete_FdmSquareRootFwdOp(FdmSquareRootFwdOp self)"},
	 { "FdmSquareRootFwdOp_swigregister", FdmSquareRootFwdOp_swigregister, METH_O, NULL},
	 { "FdmSquareRootFwdOp_swiginit", FdmSquareRootFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonFwdOp", _wrap_new_FdmHestonFwdOp, METH_VARARGS, "FdmHestonFwdOp(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< HestonProcess > const & process, FdmSquareRootFwdOp::TransformationType type=Plain, ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >())"},
	 { "delete_FdmHestonFwdOp", _wrap_delete_FdmHestonFwdOp, METH_O, "delete_FdmHestonFwdOp(FdmHestonFwdOp self)"},
	 { "FdmHestonFwdOp_swigregister", FdmHestonFwdOp_swigregister, METH_O, NULL},
	 { "FdmHestonFwdOp_swiginit", FdmHestonFwdOp_swiginit, METH_VARARGS, NULL},
	 { "new_TripleBandLinearOp", _wrap_new_TripleBandLinearOp, METH_VARARGS, "new_TripleBandLinearOp(Size direction, ext::shared_ptr< FdmMesher > const & mesher) -> TripleBandLinearOp"},
	 { "TripleBandLinearOp_apply", _wrap_TripleBandLinearOp_apply, METH_VARARGS, "TripleBandLinearOp_apply(TripleBandLinearOp self, Array r) -> Array"},
	 { "TripleBandLinearOp_solve_splitting", _wrap_TripleBandLinearOp_solve_splitting, METH_VARARGS, "TripleBandLinearOp_solve_splitting(TripleBandLinearOp self, Array r, Real a, Real b=1.0) -> Array"},
	 { "TripleBandLinearOp_mult", _wrap_TripleBandLinearOp_mult, METH_VARARGS, "TripleBandLinearOp_mult(TripleBandLinearOp self, Array u) -> TripleBandLinearOp"},
	 { "TripleBandLinearOp_multR", _wrap_TripleBandLinearOp_multR, METH_VARARGS, "TripleBandLinearOp_multR(TripleBandLinearOp self, Array u) -> TripleBandLinearOp"},
	 { "TripleBandLinearOp_add", _wrap_TripleBandLinearOp_add, METH_VARARGS, "\n"
		"TripleBandLinearOp_add(TripleBandLinearOp self, TripleBandLinearOp m) -> TripleBandLinearOp\n"
		"TripleBandLinearOp_add(TripleBandLinearOp self, Array u) -> TripleBandLinearOp\n"
		""},
	 { "TripleBandLinearOp_axpyb", _wrap_TripleBandLinearOp_axpyb, METH_VARARGS, "TripleBandLinearOp_axpyb(TripleBandLinearOp self, Array a, TripleBandLinearOp x, TripleBandLinearOp y, Array b)"},
	 { "TripleBandLinearOp_swap", _wrap_TripleBandLinearOp_swap, METH_VARARGS, "TripleBandLinearOp_swap(TripleBandLinearOp self, TripleBandLinearOp m)"},
	 { "delete_TripleBandLinearOp", _wrap_delete_TripleBandLinearOp, METH_O, "delete_TripleBandLinearOp(TripleBandLinearOp self)"},
	 { "TripleBandLinearOp_swigregister", TripleBandLinearOp_swigregister, METH_O, NULL},
	 { "TripleBandLinearOp_swiginit", TripleBandLinearOp_swiginit, METH_VARARGS, NULL},
	 { "new_FirstDerivativeOp", _wrap_new_FirstDerivativeOp, METH_VARARGS, "new_FirstDerivativeOp(Size direction, ext::shared_ptr< FdmMesher > const & mesher) -> FirstDerivativeOp"},
	 { "delete_FirstDerivativeOp", _wrap_delete_FirstDerivativeOp, METH_O, "delete_FirstDerivativeOp(FirstDerivativeOp self)"},
	 { "FirstDerivativeOp_swigregister", FirstDerivativeOp_swigregister, METH_O, NULL},
	 { "FirstDerivativeOp_swiginit", FirstDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_SecondDerivativeOp", _wrap_new_SecondDerivativeOp, METH_VARARGS, "new_SecondDerivativeOp(Size direction, ext::shared_ptr< FdmMesher > const & mesher) -> SecondDerivativeOp"},
	 { "delete_SecondDerivativeOp", _wrap_delete_SecondDerivativeOp, METH_O, "delete_SecondDerivativeOp(SecondDerivativeOp self)"},
	 { "SecondDerivativeOp_swigregister", SecondDerivativeOp_swigregister, METH_O, NULL},
	 { "SecondDerivativeOp_swiginit", SecondDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_NinePointLinearOp", _wrap_new_NinePointLinearOp, METH_VARARGS, "new_NinePointLinearOp(Size d0, Size d1, ext::shared_ptr< FdmMesher > const & mesher) -> NinePointLinearOp"},
	 { "delete_NinePointLinearOp", _wrap_delete_NinePointLinearOp, METH_O, "delete_NinePointLinearOp(NinePointLinearOp self)"},
	 { "NinePointLinearOp_swigregister", NinePointLinearOp_swigregister, METH_O, NULL},
	 { "NinePointLinearOp_swiginit", NinePointLinearOp_swiginit, METH_VARARGS, NULL},
	 { "new_SecondOrderMixedDerivativeOp", _wrap_new_SecondOrderMixedDerivativeOp, METH_VARARGS, "new_SecondOrderMixedDerivativeOp(Size d0, Size d1, ext::shared_ptr< FdmMesher > const & mesher) -> SecondOrderMixedDerivativeOp"},
	 { "delete_SecondOrderMixedDerivativeOp", _wrap_delete_SecondOrderMixedDerivativeOp, METH_O, "delete_SecondOrderMixedDerivativeOp(SecondOrderMixedDerivativeOp self)"},
	 { "SecondOrderMixedDerivativeOp_swigregister", SecondOrderMixedDerivativeOp_swigregister, METH_O, NULL},
	 { "SecondOrderMixedDerivativeOp_swiginit", SecondOrderMixedDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_NthOrderDerivativeOp", _wrap_new_NthOrderDerivativeOp, METH_VARARGS, "new_NthOrderDerivativeOp(Size direction, Size order, Integer nPoints, ext::shared_ptr< FdmMesher > const & mesher) -> NthOrderDerivativeOp"},
	 { "delete_NthOrderDerivativeOp", _wrap_delete_NthOrderDerivativeOp, METH_O, "delete_NthOrderDerivativeOp(NthOrderDerivativeOp self)"},
	 { "NthOrderDerivativeOp_swigregister", NthOrderDerivativeOp_swigregister, METH_O, NULL},
	 { "NthOrderDerivativeOp_swiginit", NthOrderDerivativeOp_swiginit, METH_VARARGS, NULL},
	 { "new_CraigSneydScheme", _wrap_new_CraigSneydScheme, METH_VARARGS, "CraigSneydScheme(Real theta, Real mu, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet())"},
	 { "CraigSneydScheme_step", _wrap_CraigSneydScheme_step, METH_VARARGS, "CraigSneydScheme_step(CraigSneydScheme self, Array a, Time t)"},
	 { "CraigSneydScheme_setStep", _wrap_CraigSneydScheme_setStep, METH_VARARGS, "CraigSneydScheme_setStep(CraigSneydScheme self, Time dt)"},
	 { "delete_CraigSneydScheme", _wrap_delete_CraigSneydScheme, METH_O, "delete_CraigSneydScheme(CraigSneydScheme self)"},
	 { "CraigSneydScheme_swigregister", CraigSneydScheme_swigregister, METH_O, NULL},
	 { "CraigSneydScheme_swiginit", CraigSneydScheme_swiginit, METH_VARARGS, NULL},
	 { "new_ImplicitEulerScheme", (PyCFunction)(void(*)(void))_wrap_new_ImplicitEulerScheme, METH_VARARGS|METH_KEYWORDS, "new_ImplicitEulerScheme(ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet(), Real relTol=1e-8, ImplicitEulerScheme::SolverType solverType=BiCGstab) -> ImplicitEulerScheme"},
	 { "ImplicitEulerScheme_step", _wrap_ImplicitEulerScheme_step, METH_VARARGS, "ImplicitEulerScheme_step(ImplicitEulerScheme self, Array a, Time t)"},
	 { "ImplicitEulerScheme_setStep", _wrap_ImplicitEulerScheme_setStep, METH_VARARGS, "ImplicitEulerScheme_setStep(ImplicitEulerScheme self, Time dt)"},
	 { "ImplicitEulerScheme_numberOfIterations", _wrap_ImplicitEulerScheme_numberOfIterations, METH_O, "ImplicitEulerScheme_numberOfIterations(ImplicitEulerScheme self) -> Size"},
	 { "delete_ImplicitEulerScheme", _wrap_delete_ImplicitEulerScheme, METH_O, "delete_ImplicitEulerScheme(ImplicitEulerScheme self)"},
	 { "ImplicitEulerScheme_swigregister", ImplicitEulerScheme_swigregister, METH_O, NULL},
	 { "ImplicitEulerScheme_swiginit", ImplicitEulerScheme_swiginit, METH_VARARGS, NULL},
	 { "new_CrankNicolsonScheme", (PyCFunction)(void(*)(void))_wrap_new_CrankNicolsonScheme, METH_VARARGS|METH_KEYWORDS, "new_CrankNicolsonScheme(Real theta, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet(), Real relTol=1e-8, ImplicitEulerScheme::SolverType solverType=BiCGstab) -> CrankNicolsonScheme"},
	 { "CrankNicolsonScheme_step", _wrap_CrankNicolsonScheme_step, METH_VARARGS, "CrankNicolsonScheme_step(CrankNicolsonScheme self, Array a, Time t)"},
	 { "CrankNicolsonScheme_setStep", _wrap_CrankNicolsonScheme_setStep, METH_VARARGS, "CrankNicolsonScheme_setStep(CrankNicolsonScheme self, Time dt)"},
	 { "CrankNicolsonScheme_numberOfIterations", _wrap_CrankNicolsonScheme_numberOfIterations, METH_O, "CrankNicolsonScheme_numberOfIterations(CrankNicolsonScheme self) -> Size"},
	 { "delete_CrankNicolsonScheme", _wrap_delete_CrankNicolsonScheme, METH_O, "delete_CrankNicolsonScheme(CrankNicolsonScheme self)"},
	 { "CrankNicolsonScheme_swigregister", CrankNicolsonScheme_swigregister, METH_O, NULL},
	 { "CrankNicolsonScheme_swiginit", CrankNicolsonScheme_swiginit, METH_VARARGS, NULL},
	 { "new_DouglasScheme", _wrap_new_DouglasScheme, METH_VARARGS, "DouglasScheme(Real theta, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet())"},
	 { "DouglasScheme_step", _wrap_DouglasScheme_step, METH_VARARGS, "DouglasScheme_step(DouglasScheme self, Array a, Time t)"},
	 { "DouglasScheme_setStep", _wrap_DouglasScheme_setStep, METH_VARARGS, "DouglasScheme_setStep(DouglasScheme self, Time dt)"},
	 { "delete_DouglasScheme", _wrap_delete_DouglasScheme, METH_O, "delete_DouglasScheme(DouglasScheme self)"},
	 { "DouglasScheme_swigregister", DouglasScheme_swigregister, METH_O, NULL},
	 { "DouglasScheme_swiginit", DouglasScheme_swiginit, METH_VARARGS, NULL},
	 { "new_ExplicitEulerScheme", _wrap_new_ExplicitEulerScheme, METH_VARARGS, "ExplicitEulerScheme(ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet())"},
	 { "ExplicitEulerScheme_step", _wrap_ExplicitEulerScheme_step, METH_VARARGS, "ExplicitEulerScheme_step(ExplicitEulerScheme self, Array a, Time t)"},
	 { "ExplicitEulerScheme_setStep", _wrap_ExplicitEulerScheme_setStep, METH_VARARGS, "ExplicitEulerScheme_setStep(ExplicitEulerScheme self, Time dt)"},
	 { "delete_ExplicitEulerScheme", _wrap_delete_ExplicitEulerScheme, METH_O, "delete_ExplicitEulerScheme(ExplicitEulerScheme self)"},
	 { "ExplicitEulerScheme_swigregister", ExplicitEulerScheme_swigregister, METH_O, NULL},
	 { "ExplicitEulerScheme_swiginit", ExplicitEulerScheme_swiginit, METH_VARARGS, NULL},
	 { "new_HundsdorferScheme", _wrap_new_HundsdorferScheme, METH_VARARGS, "HundsdorferScheme(Real theta, Real mu, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet())"},
	 { "HundsdorferScheme_step", _wrap_HundsdorferScheme_step, METH_VARARGS, "HundsdorferScheme_step(HundsdorferScheme self, Array a, Time t)"},
	 { "HundsdorferScheme_setStep", _wrap_HundsdorferScheme_setStep, METH_VARARGS, "HundsdorferScheme_setStep(HundsdorferScheme self, Time dt)"},
	 { "delete_HundsdorferScheme", _wrap_delete_HundsdorferScheme, METH_O, "delete_HundsdorferScheme(HundsdorferScheme self)"},
	 { "HundsdorferScheme_swigregister", HundsdorferScheme_swigregister, METH_O, NULL},
	 { "HundsdorferScheme_swiginit", HundsdorferScheme_swiginit, METH_VARARGS, NULL},
	 { "new_MethodOfLinesScheme", _wrap_new_MethodOfLinesScheme, METH_VARARGS, "MethodOfLinesScheme(Real const eps, Real const relInitStepSize, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet())"},
	 { "MethodOfLinesScheme_step", _wrap_MethodOfLinesScheme_step, METH_VARARGS, "MethodOfLinesScheme_step(MethodOfLinesScheme self, Array a, Time t)"},
	 { "MethodOfLinesScheme_setStep", _wrap_MethodOfLinesScheme_setStep, METH_VARARGS, "MethodOfLinesScheme_setStep(MethodOfLinesScheme self, Time dt)"},
	 { "delete_MethodOfLinesScheme", _wrap_delete_MethodOfLinesScheme, METH_O, "delete_MethodOfLinesScheme(MethodOfLinesScheme self)"},
	 { "MethodOfLinesScheme_swigregister", MethodOfLinesScheme_swigregister, METH_O, NULL},
	 { "MethodOfLinesScheme_swiginit", MethodOfLinesScheme_swiginit, METH_VARARGS, NULL},
	 { "new_ModifiedCraigSneydScheme", _wrap_new_ModifiedCraigSneydScheme, METH_VARARGS, "ModifiedCraigSneydScheme(Real theta, Real mu, ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet=FdmBoundaryConditionSet())"},
	 { "ModifiedCraigSneydScheme_step", _wrap_ModifiedCraigSneydScheme_step, METH_VARARGS, "ModifiedCraigSneydScheme_step(ModifiedCraigSneydScheme self, Array a, Time t)"},
	 { "ModifiedCraigSneydScheme_setStep", _wrap_ModifiedCraigSneydScheme_setStep, METH_VARARGS, "ModifiedCraigSneydScheme_setStep(ModifiedCraigSneydScheme self, Time dt)"},
	 { "delete_ModifiedCraigSneydScheme", _wrap_delete_ModifiedCraigSneydScheme, METH_O, "delete_ModifiedCraigSneydScheme(ModifiedCraigSneydScheme self)"},
	 { "ModifiedCraigSneydScheme_swigregister", ModifiedCraigSneydScheme_swigregister, METH_O, NULL},
	 { "ModifiedCraigSneydScheme_swiginit", ModifiedCraigSneydScheme_swiginit, METH_VARARGS, NULL},
	 { "FdmStepCondition_applyTo", _wrap_FdmStepCondition_applyTo, METH_VARARGS, "FdmStepCondition_applyTo(FdmStepCondition self, Array a, Time t)"},
	 { "delete_FdmStepCondition", _wrap_delete_FdmStepCondition, METH_O, "delete_FdmStepCondition(FdmStepCondition self)"},
	 { "FdmStepCondition_swigregister", FdmStepCondition_swigregister, METH_O, NULL},
	 { "new_FdmStepConditionProxy", _wrap_new_FdmStepConditionProxy, METH_O, "new_FdmStepConditionProxy(PyObject * callback) -> FdmStepConditionProxy"},
	 { "delete_FdmStepConditionProxy", _wrap_delete_FdmStepConditionProxy, METH_O, "delete_FdmStepConditionProxy(FdmStepConditionProxy self)"},
	 { "FdmStepConditionProxy_swigregister", FdmStepConditionProxy_swigregister, METH_O, NULL},
	 { "FdmStepConditionProxy_swiginit", FdmStepConditionProxy_swiginit, METH_VARARGS, NULL},
	 { "FdmInnerValueCalculator_innerValue", _wrap_FdmInnerValueCalculator_innerValue, METH_VARARGS, "FdmInnerValueCalculator_innerValue(FdmInnerValueCalculator self, FdmLinearOpIterator iter, Time t) -> Real"},
	 { "FdmInnerValueCalculator_avgInnerValue", _wrap_FdmInnerValueCalculator_avgInnerValue, METH_VARARGS, "FdmInnerValueCalculator_avgInnerValue(FdmInnerValueCalculator self, FdmLinearOpIterator iter, Time t) -> Real"},
	 { "delete_FdmInnerValueCalculator", _wrap_delete_FdmInnerValueCalculator, METH_O, "delete_FdmInnerValueCalculator(FdmInnerValueCalculator self)"},
	 { "FdmInnerValueCalculator_swigregister", FdmInnerValueCalculator_swigregister, METH_O, NULL},
	 { "new_FdmInnerValueCalculatorProxy", _wrap_new_FdmInnerValueCalculatorProxy, METH_O, "new_FdmInnerValueCalculatorProxy(PyObject * callback) -> FdmInnerValueCalculatorProxy"},
	 { "delete_FdmInnerValueCalculatorProxy", _wrap_delete_FdmInnerValueCalculatorProxy, METH_O, "delete_FdmInnerValueCalculatorProxy(FdmInnerValueCalculatorProxy self)"},
	 { "FdmInnerValueCalculatorProxy_swigregister", FdmInnerValueCalculatorProxy_swigregister, METH_O, NULL},
	 { "FdmInnerValueCalculatorProxy_swiginit", FdmInnerValueCalculatorProxy_swiginit, METH_VARARGS, NULL},
	 { "new_FdmCellAveragingInnerValue", _wrap_new_FdmCellAveragingInnerValue, METH_VARARGS, "\n"
		"FdmCellAveragingInnerValue(ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher, Size direction, PyObject * gridMapping)\n"
		"new_FdmCellAveragingInnerValue(ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmCellAveragingInnerValue\n"
		""},
	 { "delete_FdmCellAveragingInnerValue", _wrap_delete_FdmCellAveragingInnerValue, METH_O, "delete_FdmCellAveragingInnerValue(FdmCellAveragingInnerValue self)"},
	 { "FdmCellAveragingInnerValue_swigregister", FdmCellAveragingInnerValue_swigregister, METH_O, NULL},
	 { "FdmCellAveragingInnerValue_swiginit", FdmCellAveragingInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLogInnerValue", _wrap_new_FdmLogInnerValue, METH_VARARGS, "new_FdmLogInnerValue(ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmLogInnerValue"},
	 { "delete_FdmLogInnerValue", _wrap_delete_FdmLogInnerValue, METH_O, "delete_FdmLogInnerValue(FdmLogInnerValue self)"},
	 { "FdmLogInnerValue_swigregister", FdmLogInnerValue_swigregister, METH_O, NULL},
	 { "FdmLogInnerValue_swiginit", FdmLogInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmLogBasketInnerValue", _wrap_new_FdmLogBasketInnerValue, METH_VARARGS, "new_FdmLogBasketInnerValue(ext::shared_ptr< BasketPayoff > const & payoff, ext::shared_ptr< FdmMesher > const & mesher) -> FdmLogBasketInnerValue"},
	 { "delete_FdmLogBasketInnerValue", _wrap_delete_FdmLogBasketInnerValue, METH_O, "delete_FdmLogBasketInnerValue(FdmLogBasketInnerValue self)"},
	 { "FdmLogBasketInnerValue_swigregister", FdmLogBasketInnerValue_swigregister, METH_O, NULL},
	 { "FdmLogBasketInnerValue_swiginit", FdmLogBasketInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmZeroInnerValue", _wrap_new_FdmZeroInnerValue, METH_NOARGS, "new_FdmZeroInnerValue() -> FdmZeroInnerValue"},
	 { "delete_FdmZeroInnerValue", _wrap_delete_FdmZeroInnerValue, METH_O, "delete_FdmZeroInnerValue(FdmZeroInnerValue self)"},
	 { "FdmZeroInnerValue_swigregister", FdmZeroInnerValue_swigregister, METH_O, NULL},
	 { "FdmZeroInnerValue_swiginit", FdmZeroInnerValue_swiginit, METH_VARARGS, NULL},
	 { "TimeToDateMap_iterator", _wrap_TimeToDateMap_iterator, METH_O, "TimeToDateMap_iterator(TimeToDateMap self) -> SwigPyIterator"},
	 { "TimeToDateMap___nonzero__", _wrap_TimeToDateMap___nonzero__, METH_O, "TimeToDateMap___nonzero__(TimeToDateMap self) -> bool"},
	 { "TimeToDateMap___bool__", _wrap_TimeToDateMap___bool__, METH_O, "TimeToDateMap___bool__(TimeToDateMap self) -> bool"},
	 { "TimeToDateMap___len__", _wrap_TimeToDateMap___len__, METH_O, "TimeToDateMap___len__(TimeToDateMap self) -> std::map< double,Date >::size_type"},
	 { "TimeToDateMap___getitem__", _wrap_TimeToDateMap___getitem__, METH_VARARGS, "TimeToDateMap___getitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key) -> Date"},
	 { "TimeToDateMap___delitem__", _wrap_TimeToDateMap___delitem__, METH_VARARGS, "TimeToDateMap___delitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key)"},
	 { "TimeToDateMap_has_key", _wrap_TimeToDateMap_has_key, METH_VARARGS, "TimeToDateMap_has_key(TimeToDateMap self, std::map< double,Date >::key_type const & key) -> bool"},
	 { "TimeToDateMap_keys", _wrap_TimeToDateMap_keys, METH_O, "TimeToDateMap_keys(TimeToDateMap self) -> PyObject *"},
	 { "TimeToDateMap_values", _wrap_TimeToDateMap_values, METH_O, "TimeToDateMap_values(TimeToDateMap self) -> PyObject *"},
	 { "TimeToDateMap_items", _wrap_TimeToDateMap_items, METH_O, "TimeToDateMap_items(TimeToDateMap self) -> PyObject *"},
	 { "TimeToDateMap___contains__", _wrap_TimeToDateMap___contains__, METH_VARARGS, "TimeToDateMap___contains__(TimeToDateMap self, std::map< double,Date >::key_type const & key) -> bool"},
	 { "TimeToDateMap_key_iterator", _wrap_TimeToDateMap_key_iterator, METH_O, "TimeToDateMap_key_iterator(TimeToDateMap self) -> SwigPyIterator"},
	 { "TimeToDateMap_value_iterator", _wrap_TimeToDateMap_value_iterator, METH_O, "TimeToDateMap_value_iterator(TimeToDateMap self) -> SwigPyIterator"},
	 { "TimeToDateMap___setitem__", _wrap_TimeToDateMap___setitem__, METH_VARARGS, "\n"
		"TimeToDateMap___setitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key)\n"
		"TimeToDateMap___setitem__(TimeToDateMap self, std::map< double,Date >::key_type const & key, Date x)\n"
		""},
	 { "TimeToDateMap_asdict", _wrap_TimeToDateMap_asdict, METH_O, "TimeToDateMap_asdict(TimeToDateMap self) -> PyObject *"},
	 { "new_TimeToDateMap", _wrap_new_TimeToDateMap, METH_VARARGS, "\n"
		"TimeToDateMap(std::less< double > const & other)\n"
		"TimeToDateMap()\n"
		"new_TimeToDateMap(TimeToDateMap other) -> TimeToDateMap\n"
		""},
	 { "TimeToDateMap_empty", _wrap_TimeToDateMap_empty, METH_O, "TimeToDateMap_empty(TimeToDateMap self) -> bool"},
	 { "TimeToDateMap_size", _wrap_TimeToDateMap_size, METH_O, "TimeToDateMap_size(TimeToDateMap self) -> std::map< double,Date >::size_type"},
	 { "TimeToDateMap_swap", _wrap_TimeToDateMap_swap, METH_VARARGS, "TimeToDateMap_swap(TimeToDateMap self, TimeToDateMap v)"},
	 { "TimeToDateMap_begin", _wrap_TimeToDateMap_begin, METH_O, "TimeToDateMap_begin(TimeToDateMap self) -> std::map< double,Date >::iterator"},
	 { "TimeToDateMap_end", _wrap_TimeToDateMap_end, METH_O, "TimeToDateMap_end(TimeToDateMap self) -> std::map< double,Date >::iterator"},
	 { "TimeToDateMap_rbegin", _wrap_TimeToDateMap_rbegin, METH_O, "TimeToDateMap_rbegin(TimeToDateMap self) -> std::map< double,Date >::reverse_iterator"},
	 { "TimeToDateMap_rend", _wrap_TimeToDateMap_rend, METH_O, "TimeToDateMap_rend(TimeToDateMap self) -> std::map< double,Date >::reverse_iterator"},
	 { "TimeToDateMap_clear", _wrap_TimeToDateMap_clear, METH_O, "TimeToDateMap_clear(TimeToDateMap self)"},
	 { "TimeToDateMap_get_allocator", _wrap_TimeToDateMap_get_allocator, METH_O, "TimeToDateMap_get_allocator(TimeToDateMap self) -> std::map< double,Date >::allocator_type"},
	 { "TimeToDateMap_count", _wrap_TimeToDateMap_count, METH_VARARGS, "TimeToDateMap_count(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::size_type"},
	 { "TimeToDateMap_erase", _wrap_TimeToDateMap_erase, METH_VARARGS, "\n"
		"TimeToDateMap_erase(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::size_type\n"
		"TimeToDateMap_erase(TimeToDateMap self, std::map< double,Date >::iterator position)\n"
		"TimeToDateMap_erase(TimeToDateMap self, std::map< double,Date >::iterator first, std::map< double,Date >::iterator last)\n"
		""},
	 { "TimeToDateMap_find", _wrap_TimeToDateMap_find, METH_VARARGS, "TimeToDateMap_find(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::iterator"},
	 { "TimeToDateMap_lower_bound", _wrap_TimeToDateMap_lower_bound, METH_VARARGS, "TimeToDateMap_lower_bound(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::iterator"},
	 { "TimeToDateMap_upper_bound", _wrap_TimeToDateMap_upper_bound, METH_VARARGS, "TimeToDateMap_upper_bound(TimeToDateMap self, std::map< double,Date >::key_type const & x) -> std::map< double,Date >::iterator"},
	 { "delete_TimeToDateMap", _wrap_delete_TimeToDateMap, METH_O, "delete_TimeToDateMap(TimeToDateMap self)"},
	 { "TimeToDateMap_swigregister", TimeToDateMap_swigregister, METH_O, NULL},
	 { "TimeToDateMap_swiginit", TimeToDateMap_swiginit, METH_VARARGS, NULL},
	 { "new_FdmAffineG2ModelSwapInnerValue", _wrap_new_FdmAffineG2ModelSwapInnerValue, METH_VARARGS, "new_FdmAffineG2ModelSwapInnerValue(ext::shared_ptr< G2 > const & disModel, ext::shared_ptr< G2 > const & fwdModel, ext::shared_ptr< VanillaSwap > const & swap, TimeToDateMap exerciseDates, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmAffineG2ModelSwapInnerValue"},
	 { "delete_FdmAffineG2ModelSwapInnerValue", _wrap_delete_FdmAffineG2ModelSwapInnerValue, METH_O, "delete_FdmAffineG2ModelSwapInnerValue(FdmAffineG2ModelSwapInnerValue self)"},
	 { "FdmAffineG2ModelSwapInnerValue_swigregister", FdmAffineG2ModelSwapInnerValue_swigregister, METH_O, NULL},
	 { "FdmAffineG2ModelSwapInnerValue_swiginit", FdmAffineG2ModelSwapInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmAffineHullWhiteModelSwapInnerValue", _wrap_new_FdmAffineHullWhiteModelSwapInnerValue, METH_VARARGS, "new_FdmAffineHullWhiteModelSwapInnerValue(ext::shared_ptr< HullWhite > const & disModel, ext::shared_ptr< HullWhite > const & fwdModel, ext::shared_ptr< VanillaSwap > const & swap, TimeToDateMap exerciseDates, ext::shared_ptr< FdmMesher > const & mesher, Size direction) -> FdmAffineHullWhiteModelSwapInnerValue"},
	 { "delete_FdmAffineHullWhiteModelSwapInnerValue", _wrap_delete_FdmAffineHullWhiteModelSwapInnerValue, METH_O, "delete_FdmAffineHullWhiteModelSwapInnerValue(FdmAffineHullWhiteModelSwapInnerValue self)"},
	 { "FdmAffineHullWhiteModelSwapInnerValue_swigregister", FdmAffineHullWhiteModelSwapInnerValue_swigregister, METH_O, NULL},
	 { "FdmAffineHullWhiteModelSwapInnerValue_swiginit", FdmAffineHullWhiteModelSwapInnerValue_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSnapshotCondition", _wrap_new_FdmSnapshotCondition, METH_O, "new_FdmSnapshotCondition(Time t) -> FdmSnapshotCondition"},
	 { "FdmSnapshotCondition_getTime", _wrap_FdmSnapshotCondition_getTime, METH_O, "FdmSnapshotCondition_getTime(FdmSnapshotCondition self) -> Time"},
	 { "FdmSnapshotCondition_getValues", _wrap_FdmSnapshotCondition_getValues, METH_O, "FdmSnapshotCondition_getValues(FdmSnapshotCondition self) -> Array"},
	 { "delete_FdmSnapshotCondition", _wrap_delete_FdmSnapshotCondition, METH_O, "delete_FdmSnapshotCondition(FdmSnapshotCondition self)"},
	 { "FdmSnapshotCondition_swigregister", FdmSnapshotCondition_swigregister, METH_O, NULL},
	 { "FdmSnapshotCondition_swiginit", FdmSnapshotCondition_swiginit, METH_VARARGS, NULL},
	 { "FdmStepConditionVector_iterator", _wrap_FdmStepConditionVector_iterator, METH_O, "FdmStepConditionVector_iterator(FdmStepConditionVector self) -> SwigPyIterator"},
	 { "FdmStepConditionVector___nonzero__", _wrap_FdmStepConditionVector___nonzero__, METH_O, "FdmStepConditionVector___nonzero__(FdmStepConditionVector self) -> bool"},
	 { "FdmStepConditionVector___bool__", _wrap_FdmStepConditionVector___bool__, METH_O, "FdmStepConditionVector___bool__(FdmStepConditionVector self) -> bool"},
	 { "FdmStepConditionVector___len__", _wrap_FdmStepConditionVector___len__, METH_O, "FdmStepConditionVector___len__(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type"},
	 { "FdmStepConditionVector___getslice__", _wrap_FdmStepConditionVector___getslice__, METH_VARARGS, "FdmStepConditionVector___getslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j) -> FdmStepConditionVector"},
	 { "FdmStepConditionVector___setslice__", _wrap_FdmStepConditionVector___setslice__, METH_VARARGS, "\n"
		"FdmStepConditionVector___setslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j)\n"
		"FdmStepConditionVector___setslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j, FdmStepConditionVector v)\n"
		""},
	 { "FdmStepConditionVector___delslice__", _wrap_FdmStepConditionVector___delslice__, METH_VARARGS, "FdmStepConditionVector___delslice__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type j)"},
	 { "FdmStepConditionVector___delitem__", _wrap_FdmStepConditionVector___delitem__, METH_VARARGS, "\n"
		"FdmStepConditionVector___delitem__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i)\n"
		"FdmStepConditionVector___delitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice)\n"
		""},
	 { "FdmStepConditionVector___getitem__", _wrap_FdmStepConditionVector___getitem__, METH_VARARGS, "\n"
		"FdmStepConditionVector___getitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice) -> FdmStepConditionVector\n"
		"FdmStepConditionVector___getitem__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &\n"
		""},
	 { "FdmStepConditionVector___setitem__", _wrap_FdmStepConditionVector___setitem__, METH_VARARGS, "\n"
		"FdmStepConditionVector___setitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice, FdmStepConditionVector v)\n"
		"FdmStepConditionVector___setitem__(FdmStepConditionVector self, SWIGPY_SLICEOBJECT * slice)\n"
		"FdmStepConditionVector___setitem__(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::difference_type i, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)\n"
		""},
	 { "FdmStepConditionVector_pop", _wrap_FdmStepConditionVector_pop, METH_O, "FdmStepConditionVector_pop(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type"},
	 { "FdmStepConditionVector_append", _wrap_FdmStepConditionVector_append, METH_VARARGS, "FdmStepConditionVector_append(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)"},
	 { "FdmStepConditionVector_empty", _wrap_FdmStepConditionVector_empty, METH_O, "FdmStepConditionVector_empty(FdmStepConditionVector self) -> bool"},
	 { "FdmStepConditionVector_size", _wrap_FdmStepConditionVector_size, METH_O, "FdmStepConditionVector_size(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type"},
	 { "FdmStepConditionVector_swap", _wrap_FdmStepConditionVector_swap, METH_VARARGS, "FdmStepConditionVector_swap(FdmStepConditionVector self, FdmStepConditionVector v)"},
	 { "FdmStepConditionVector_begin", _wrap_FdmStepConditionVector_begin, METH_O, "FdmStepConditionVector_begin(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator"},
	 { "FdmStepConditionVector_end", _wrap_FdmStepConditionVector_end, METH_O, "FdmStepConditionVector_end(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator"},
	 { "FdmStepConditionVector_rbegin", _wrap_FdmStepConditionVector_rbegin, METH_O, "FdmStepConditionVector_rbegin(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator"},
	 { "FdmStepConditionVector_rend", _wrap_FdmStepConditionVector_rend, METH_O, "FdmStepConditionVector_rend(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::reverse_iterator"},
	 { "FdmStepConditionVector_clear", _wrap_FdmStepConditionVector_clear, METH_O, "FdmStepConditionVector_clear(FdmStepConditionVector self)"},
	 { "FdmStepConditionVector_get_allocator", _wrap_FdmStepConditionVector_get_allocator, METH_O, "FdmStepConditionVector_get_allocator(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::allocator_type"},
	 { "FdmStepConditionVector_pop_back", _wrap_FdmStepConditionVector_pop_back, METH_O, "FdmStepConditionVector_pop_back(FdmStepConditionVector self)"},
	 { "FdmStepConditionVector_erase", _wrap_FdmStepConditionVector_erase, METH_VARARGS, "\n"
		"FdmStepConditionVector_erase(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator\n"
		"FdmStepConditionVector_erase(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator first, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator last) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator\n"
		""},
	 { "new_FdmStepConditionVector", _wrap_new_FdmStepConditionVector, METH_VARARGS, "\n"
		"FdmStepConditionVector()\n"
		"FdmStepConditionVector(FdmStepConditionVector other)\n"
		"FdmStepConditionVector(std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type size)\n"
		"new_FdmStepConditionVector(std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type size, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & value) -> FdmStepConditionVector\n"
		""},
	 { "FdmStepConditionVector_push_back", _wrap_FdmStepConditionVector_push_back, METH_VARARGS, "FdmStepConditionVector_push_back(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)"},
	 { "FdmStepConditionVector_front", _wrap_FdmStepConditionVector_front, METH_O, "FdmStepConditionVector_front(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &"},
	 { "FdmStepConditionVector_back", _wrap_FdmStepConditionVector_back, METH_O, "FdmStepConditionVector_back(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const &"},
	 { "FdmStepConditionVector_assign", _wrap_FdmStepConditionVector_assign, METH_VARARGS, "FdmStepConditionVector_assign(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)"},
	 { "FdmStepConditionVector_resize", _wrap_FdmStepConditionVector_resize, METH_VARARGS, "\n"
		"FdmStepConditionVector_resize(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type new_size)\n"
		"FdmStepConditionVector_resize(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type new_size, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)\n"
		""},
	 { "FdmStepConditionVector_insert", _wrap_FdmStepConditionVector_insert, METH_VARARGS, "\n"
		"FdmStepConditionVector_insert(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator\n"
		"FdmStepConditionVector_insert(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::iterator pos, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n, std::vector< ext::shared_ptr< StepCondition< Array > > >::value_type const & x)\n"
		""},
	 { "FdmStepConditionVector_reserve", _wrap_FdmStepConditionVector_reserve, METH_VARARGS, "FdmStepConditionVector_reserve(FdmStepConditionVector self, std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type n)"},
	 { "FdmStepConditionVector_capacity", _wrap_FdmStepConditionVector_capacity, METH_O, "FdmStepConditionVector_capacity(FdmStepConditionVector self) -> std::vector< ext::shared_ptr< StepCondition< Array > > >::size_type"},
	 { "delete_FdmStepConditionVector", _wrap_delete_FdmStepConditionVector, METH_O, "delete_FdmStepConditionVector(FdmStepConditionVector self)"},
	 { "FdmStepConditionVector_swigregister", FdmStepConditionVector_swigregister, METH_O, NULL},
	 { "FdmStepConditionVector_swiginit", FdmStepConditionVector_swiginit, METH_VARARGS, NULL},
	 { "new_FdmStepConditionComposite", _wrap_new_FdmStepConditionComposite, METH_VARARGS, "new_FdmStepConditionComposite(DoubleVector stoppingTimes, FdmStepConditionVector conditions) -> FdmStepConditionComposite"},
	 { "FdmStepConditionComposite_stoppingTimes", _wrap_FdmStepConditionComposite_stoppingTimes, METH_O, "FdmStepConditionComposite_stoppingTimes(FdmStepConditionComposite self) -> DoubleVector"},
	 { "FdmStepConditionComposite_conditions", _wrap_FdmStepConditionComposite_conditions, METH_O, "FdmStepConditionComposite_conditions(FdmStepConditionComposite self) -> FdmStepConditionVector"},
	 { "FdmStepConditionComposite_joinConditions", _wrap_FdmStepConditionComposite_joinConditions, METH_VARARGS, "FdmStepConditionComposite_joinConditions(ext::shared_ptr< FdmSnapshotCondition > const & c1, ext::shared_ptr< FdmStepConditionComposite > const & c2) -> ext::shared_ptr< FdmStepConditionComposite >"},
	 { "FdmStepConditionComposite_vanillaComposite", _wrap_FdmStepConditionComposite_vanillaComposite, METH_VARARGS, "FdmStepConditionComposite_vanillaComposite(DividendSchedule schedule, ext::shared_ptr< Exercise > const & exercise, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Date refDate, DayCounter dayCounter) -> ext::shared_ptr< FdmStepConditionComposite >"},
	 { "delete_FdmStepConditionComposite", _wrap_delete_FdmStepConditionComposite, METH_O, "delete_FdmStepConditionComposite(FdmStepConditionComposite self)"},
	 { "FdmStepConditionComposite_swigregister", FdmStepConditionComposite_swigregister, METH_O, NULL},
	 { "FdmStepConditionComposite_swiginit", FdmStepConditionComposite_swiginit, METH_VARARGS, NULL},
	 { "new_FdmAmericanStepCondition", _wrap_new_FdmAmericanStepCondition, METH_VARARGS, "new_FdmAmericanStepCondition(ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator) -> FdmAmericanStepCondition"},
	 { "delete_FdmAmericanStepCondition", _wrap_delete_FdmAmericanStepCondition, METH_O, "delete_FdmAmericanStepCondition(FdmAmericanStepCondition self)"},
	 { "FdmAmericanStepCondition_swigregister", FdmAmericanStepCondition_swigregister, METH_O, NULL},
	 { "FdmAmericanStepCondition_swiginit", FdmAmericanStepCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmArithmeticAverageCondition", _wrap_new_FdmArithmeticAverageCondition, METH_VARARGS, "new_FdmArithmeticAverageCondition(DoubleVector averageTimes, Real arg2, Size pastFixings, ext::shared_ptr< FdmMesher > const & mesher, Size equityDirection) -> FdmArithmeticAverageCondition"},
	 { "delete_FdmArithmeticAverageCondition", _wrap_delete_FdmArithmeticAverageCondition, METH_O, "delete_FdmArithmeticAverageCondition(FdmArithmeticAverageCondition self)"},
	 { "FdmArithmeticAverageCondition_swigregister", FdmArithmeticAverageCondition_swigregister, METH_O, NULL},
	 { "FdmArithmeticAverageCondition_swiginit", FdmArithmeticAverageCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBermudanStepCondition", _wrap_new_FdmBermudanStepCondition, METH_VARARGS, "new_FdmBermudanStepCondition(DateVector exerciseDates, Date referenceDate, DayCounter dayCounter, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator) -> FdmBermudanStepCondition"},
	 { "FdmBermudanStepCondition_exerciseTimes", _wrap_FdmBermudanStepCondition_exerciseTimes, METH_O, "FdmBermudanStepCondition_exerciseTimes(FdmBermudanStepCondition self) -> DoubleVector"},
	 { "delete_FdmBermudanStepCondition", _wrap_delete_FdmBermudanStepCondition, METH_O, "delete_FdmBermudanStepCondition(FdmBermudanStepCondition self)"},
	 { "FdmBermudanStepCondition_swigregister", FdmBermudanStepCondition_swigregister, METH_O, NULL},
	 { "FdmBermudanStepCondition_swiginit", FdmBermudanStepCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSimpleStorageCondition", _wrap_new_FdmSimpleStorageCondition, METH_VARARGS, "new_FdmSimpleStorageCondition(DoubleVector exerciseTimes, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Real changeRate) -> FdmSimpleStorageCondition"},
	 { "delete_FdmSimpleStorageCondition", _wrap_delete_FdmSimpleStorageCondition, METH_O, "delete_FdmSimpleStorageCondition(FdmSimpleStorageCondition self)"},
	 { "FdmSimpleStorageCondition_swigregister", FdmSimpleStorageCondition_swigregister, METH_O, NULL},
	 { "FdmSimpleStorageCondition_swiginit", FdmSimpleStorageCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSimpleSwingCondition", _wrap_new_FdmSimpleSwingCondition, METH_VARARGS, "FdmSimpleSwingCondition(DoubleVector exerciseTimes, ext::shared_ptr< FdmMesher > const & mesher, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Size swingDirection, Size minExercises=0)"},
	 { "delete_FdmSimpleSwingCondition", _wrap_delete_FdmSimpleSwingCondition, METH_O, "delete_FdmSimpleSwingCondition(FdmSimpleSwingCondition self)"},
	 { "FdmSimpleSwingCondition_swigregister", FdmSimpleSwingCondition_swigregister, METH_O, NULL},
	 { "FdmSimpleSwingCondition_swiginit", FdmSimpleSwingCondition_swiginit, METH_VARARGS, NULL},
	 { "new_FdmDividendHandler", _wrap_new_FdmDividendHandler, METH_VARARGS, "new_FdmDividendHandler(DividendSchedule schedule, ext::shared_ptr< FdmMesher > const & mesher, Date referenceDate, DayCounter dayCounter, Size equityDirection) -> FdmDividendHandler"},
	 { "FdmDividendHandler_dividendTimes", _wrap_FdmDividendHandler_dividendTimes, METH_O, "FdmDividendHandler_dividendTimes(FdmDividendHandler self) -> DoubleVector"},
	 { "FdmDividendHandler_dividendDates", _wrap_FdmDividendHandler_dividendDates, METH_O, "FdmDividendHandler_dividendDates(FdmDividendHandler self) -> DateVector"},
	 { "FdmDividendHandler_dividends", _wrap_FdmDividendHandler_dividends, METH_O, "FdmDividendHandler_dividends(FdmDividendHandler self) -> DoubleVector"},
	 { "delete_FdmDividendHandler", _wrap_delete_FdmDividendHandler, METH_O, "delete_FdmDividendHandler(FdmDividendHandler self)"},
	 { "FdmDividendHandler_swigregister", FdmDividendHandler_swigregister, METH_O, NULL},
	 { "FdmDividendHandler_swiginit", FdmDividendHandler_swiginit, METH_VARARGS, NULL},
	 { "new_FdmSolverDesc", _wrap_new_FdmSolverDesc, METH_VARARGS, "new_FdmSolverDesc(ext::shared_ptr< FdmMesher > const & mesher, FdmBoundaryConditionSet bcSet, ext::shared_ptr< FdmStepConditionComposite > const & condition, ext::shared_ptr< FdmInnerValueCalculator > const & calculator, Time maturity, Size timeSteps, Size dampingSteps) -> FdmSolverDesc"},
	 { "FdmSolverDesc_getMesher", _wrap_FdmSolverDesc_getMesher, METH_O, "FdmSolverDesc_getMesher(FdmSolverDesc self) -> ext::shared_ptr< FdmMesher >"},
	 { "FdmSolverDesc_getBcSet", _wrap_FdmSolverDesc_getBcSet, METH_O, "FdmSolverDesc_getBcSet(FdmSolverDesc self) -> FdmBoundaryConditionSet"},
	 { "FdmSolverDesc_getStepConditions", _wrap_FdmSolverDesc_getStepConditions, METH_O, "FdmSolverDesc_getStepConditions(FdmSolverDesc self) -> ext::shared_ptr< FdmStepConditionComposite >"},
	 { "FdmSolverDesc_getCalculator", _wrap_FdmSolverDesc_getCalculator, METH_O, "FdmSolverDesc_getCalculator(FdmSolverDesc self) -> ext::shared_ptr< FdmInnerValueCalculator >"},
	 { "FdmSolverDesc_getMaturity", _wrap_FdmSolverDesc_getMaturity, METH_O, "FdmSolverDesc_getMaturity(FdmSolverDesc self) -> Time"},
	 { "FdmSolverDesc_getTimeSteps", _wrap_FdmSolverDesc_getTimeSteps, METH_O, "FdmSolverDesc_getTimeSteps(FdmSolverDesc self) -> Size"},
	 { "FdmSolverDesc_getDampingSteps", _wrap_FdmSolverDesc_getDampingSteps, METH_O, "FdmSolverDesc_getDampingSteps(FdmSolverDesc self) -> Size"},
	 { "delete_FdmSolverDesc", _wrap_delete_FdmSolverDesc, METH_O, "delete_FdmSolverDesc(FdmSolverDesc self)"},
	 { "FdmSolverDesc_swigregister", FdmSolverDesc_swigregister, METH_O, NULL},
	 { "FdmSolverDesc_swiginit", FdmSolverDesc_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm1DimSolver", _wrap_new_Fdm1DimSolver, METH_VARARGS, "new_Fdm1DimSolver(FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm1DimSolver"},
	 { "Fdm1DimSolver_interpolateAt", _wrap_Fdm1DimSolver_interpolateAt, METH_VARARGS, "Fdm1DimSolver_interpolateAt(Fdm1DimSolver self, Real x) -> Real"},
	 { "Fdm1DimSolver_thetaAt", _wrap_Fdm1DimSolver_thetaAt, METH_VARARGS, "Fdm1DimSolver_thetaAt(Fdm1DimSolver self, Real x) -> Real"},
	 { "Fdm1DimSolver_derivativeX", _wrap_Fdm1DimSolver_derivativeX, METH_VARARGS, "Fdm1DimSolver_derivativeX(Fdm1DimSolver self, Real x) -> Real"},
	 { "Fdm1DimSolver_derivativeXX", _wrap_Fdm1DimSolver_derivativeXX, METH_VARARGS, "Fdm1DimSolver_derivativeXX(Fdm1DimSolver self, Real x) -> Real"},
	 { "delete_Fdm1DimSolver", _wrap_delete_Fdm1DimSolver, METH_O, "delete_Fdm1DimSolver(Fdm1DimSolver self)"},
	 { "Fdm1DimSolver_swigregister", Fdm1DimSolver_swigregister, METH_O, NULL},
	 { "Fdm1DimSolver_swiginit", Fdm1DimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmBackwardSolver", _wrap_new_FdmBackwardSolver, METH_VARARGS, "new_FdmBackwardSolver(ext::shared_ptr< FdmLinearOpComposite > const & map, FdmBoundaryConditionSet bcSet, ext::shared_ptr< FdmStepConditionComposite > const condition, FdmSchemeDesc schemeDesc) -> FdmBackwardSolver"},
	 { "FdmBackwardSolver_rollback", _wrap_FdmBackwardSolver_rollback, METH_VARARGS, "FdmBackwardSolver_rollback(FdmBackwardSolver self, Array a, Time _from, Time to, Size steps, Size dampingSteps)"},
	 { "delete_FdmBackwardSolver", _wrap_delete_FdmBackwardSolver, METH_O, "delete_FdmBackwardSolver(FdmBackwardSolver self)"},
	 { "FdmBackwardSolver_swigregister", FdmBackwardSolver_swigregister, METH_O, NULL},
	 { "FdmBackwardSolver_swiginit", FdmBackwardSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm2dBlackScholesSolver", (PyCFunction)(void(*)(void))_wrap_new_Fdm2dBlackScholesSolver, METH_VARARGS|METH_KEYWORDS, "new_Fdm2dBlackScholesSolver(ext::shared_ptr< GeneralizedBlackScholesProcess > const & p1, ext::shared_ptr< GeneralizedBlackScholesProcess > const & p2, Real const correlation, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), bool localVol=False, Real illegalLocalVolOverwrite=-Null< Real >()) -> Fdm2dBlackScholesSolver"},
	 { "Fdm2dBlackScholesSolver_valueAt", _wrap_Fdm2dBlackScholesSolver_valueAt, METH_VARARGS, "Fdm2dBlackScholesSolver_valueAt(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "Fdm2dBlackScholesSolver_thetaAt", _wrap_Fdm2dBlackScholesSolver_thetaAt, METH_VARARGS, "Fdm2dBlackScholesSolver_thetaAt(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "Fdm2dBlackScholesSolver_deltaXat", _wrap_Fdm2dBlackScholesSolver_deltaXat, METH_VARARGS, "Fdm2dBlackScholesSolver_deltaXat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "Fdm2dBlackScholesSolver_deltaYat", _wrap_Fdm2dBlackScholesSolver_deltaYat, METH_VARARGS, "Fdm2dBlackScholesSolver_deltaYat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "Fdm2dBlackScholesSolver_gammaXat", _wrap_Fdm2dBlackScholesSolver_gammaXat, METH_VARARGS, "Fdm2dBlackScholesSolver_gammaXat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "Fdm2dBlackScholesSolver_gammaYat", _wrap_Fdm2dBlackScholesSolver_gammaYat, METH_VARARGS, "Fdm2dBlackScholesSolver_gammaYat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "Fdm2dBlackScholesSolver_gammaXYat", _wrap_Fdm2dBlackScholesSolver_gammaXYat, METH_VARARGS, "Fdm2dBlackScholesSolver_gammaXYat(Fdm2dBlackScholesSolver self, Real x, Real y) -> Real"},
	 { "delete_Fdm2dBlackScholesSolver", _wrap_delete_Fdm2dBlackScholesSolver, METH_O, "delete_Fdm2dBlackScholesSolver(Fdm2dBlackScholesSolver self)"},
	 { "Fdm2dBlackScholesSolver_swigregister", Fdm2dBlackScholesSolver_swigregister, METH_O, NULL},
	 { "Fdm2dBlackScholesSolver_swiginit", Fdm2dBlackScholesSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm2DimSolver", _wrap_new_Fdm2DimSolver, METH_VARARGS, "new_Fdm2DimSolver(FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm2DimSolver"},
	 { "Fdm2DimSolver_interpolateAt", _wrap_Fdm2DimSolver_interpolateAt, METH_VARARGS, "Fdm2DimSolver_interpolateAt(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "Fdm2DimSolver_thetaAt", _wrap_Fdm2DimSolver_thetaAt, METH_VARARGS, "Fdm2DimSolver_thetaAt(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "Fdm2DimSolver_derivativeX", _wrap_Fdm2DimSolver_derivativeX, METH_VARARGS, "Fdm2DimSolver_derivativeX(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "Fdm2DimSolver_derivativeY", _wrap_Fdm2DimSolver_derivativeY, METH_VARARGS, "Fdm2DimSolver_derivativeY(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "Fdm2DimSolver_derivativeXX", _wrap_Fdm2DimSolver_derivativeXX, METH_VARARGS, "Fdm2DimSolver_derivativeXX(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "Fdm2DimSolver_derivativeYY", _wrap_Fdm2DimSolver_derivativeYY, METH_VARARGS, "Fdm2DimSolver_derivativeYY(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "Fdm2DimSolver_derivativeXY", _wrap_Fdm2DimSolver_derivativeXY, METH_VARARGS, "Fdm2DimSolver_derivativeXY(Fdm2DimSolver self, Real x, Real y) -> Real"},
	 { "delete_Fdm2DimSolver", _wrap_delete_Fdm2DimSolver, METH_O, "delete_Fdm2DimSolver(Fdm2DimSolver self)"},
	 { "Fdm2DimSolver_swigregister", Fdm2DimSolver_swigregister, METH_O, NULL},
	 { "Fdm2DimSolver_swiginit", Fdm2DimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm3DimSolver", _wrap_new_Fdm3DimSolver, METH_VARARGS, "new_Fdm3DimSolver(FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm3DimSolver"},
	 { "Fdm3DimSolver_performCalculations", _wrap_Fdm3DimSolver_performCalculations, METH_O, "Fdm3DimSolver_performCalculations(Fdm3DimSolver self)"},
	 { "Fdm3DimSolver_interpolateAt", _wrap_Fdm3DimSolver_interpolateAt, METH_VARARGS, "Fdm3DimSolver_interpolateAt(Fdm3DimSolver self, Real x, Real y, Rate z) -> Real"},
	 { "Fdm3DimSolver_thetaAt", _wrap_Fdm3DimSolver_thetaAt, METH_VARARGS, "Fdm3DimSolver_thetaAt(Fdm3DimSolver self, Real x, Real y, Rate z) -> Real"},
	 { "delete_Fdm3DimSolver", _wrap_delete_Fdm3DimSolver, METH_O, "delete_Fdm3DimSolver(Fdm3DimSolver self)"},
	 { "Fdm3DimSolver_swigregister", Fdm3DimSolver_swigregister, METH_O, NULL},
	 { "Fdm3DimSolver_swiginit", Fdm3DimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmG2Solver", _wrap_new_FdmG2Solver, METH_VARARGS, "FdmG2Solver(ext::shared_ptr< G2 > const & model, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())"},
	 { "FdmG2Solver_valueAt", _wrap_FdmG2Solver_valueAt, METH_VARARGS, "FdmG2Solver_valueAt(FdmG2Solver self, Real x, Real y) -> Real"},
	 { "delete_FdmG2Solver", _wrap_delete_FdmG2Solver, METH_O, "delete_FdmG2Solver(FdmG2Solver self)"},
	 { "FdmG2Solver_swigregister", FdmG2Solver_swigregister, METH_O, NULL},
	 { "FdmG2Solver_swiginit", FdmG2Solver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonHullWhiteSolver", _wrap_new_FdmHestonHullWhiteSolver, METH_VARARGS, "FdmHestonHullWhiteSolver(ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< HullWhiteProcess > const & hwProcess, Rate corrEquityShortRate, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())"},
	 { "FdmHestonHullWhiteSolver_valueAt", _wrap_FdmHestonHullWhiteSolver_valueAt, METH_VARARGS, "FdmHestonHullWhiteSolver_valueAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r) -> Real"},
	 { "FdmHestonHullWhiteSolver_thetaAt", _wrap_FdmHestonHullWhiteSolver_thetaAt, METH_VARARGS, "FdmHestonHullWhiteSolver_thetaAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r) -> Real"},
	 { "FdmHestonHullWhiteSolver_deltaAt", _wrap_FdmHestonHullWhiteSolver_deltaAt, METH_VARARGS, "FdmHestonHullWhiteSolver_deltaAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r, Real eps) -> Real"},
	 { "FdmHestonHullWhiteSolver_gammaAt", _wrap_FdmHestonHullWhiteSolver_gammaAt, METH_VARARGS, "FdmHestonHullWhiteSolver_gammaAt(FdmHestonHullWhiteSolver self, Real s, Real v, Rate r, Real eps) -> Real"},
	 { "delete_FdmHestonHullWhiteSolver", _wrap_delete_FdmHestonHullWhiteSolver, METH_O, "delete_FdmHestonHullWhiteSolver(FdmHestonHullWhiteSolver self)"},
	 { "FdmHestonHullWhiteSolver_swigregister", FdmHestonHullWhiteSolver_swigregister, METH_O, NULL},
	 { "FdmHestonHullWhiteSolver_swiginit", FdmHestonHullWhiteSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHestonSolver", (PyCFunction)(void(*)(void))_wrap_new_FdmHestonSolver, METH_VARARGS|METH_KEYWORDS, "new_FdmHestonSolver(ext::shared_ptr< HestonProcess > const & process, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer(), ext::shared_ptr< FdmQuantoHelper > const & quantoHelper=ext::shared_ptr< FdmQuantoHelper >(), ext::shared_ptr< LocalVolTermStructure > const & leverageFct=ext::shared_ptr< LocalVolTermStructure >()) -> FdmHestonSolver"},
	 { "FdmHestonSolver_valueAt", _wrap_FdmHestonSolver_valueAt, METH_VARARGS, "FdmHestonSolver_valueAt(FdmHestonSolver self, Real s, Real v) -> Real"},
	 { "FdmHestonSolver_thetaAt", _wrap_FdmHestonSolver_thetaAt, METH_VARARGS, "FdmHestonSolver_thetaAt(FdmHestonSolver self, Real s, Real v) -> Real"},
	 { "FdmHestonSolver_deltaAt", _wrap_FdmHestonSolver_deltaAt, METH_VARARGS, "FdmHestonSolver_deltaAt(FdmHestonSolver self, Real s, Real v) -> Real"},
	 { "FdmHestonSolver_gammaAt", _wrap_FdmHestonSolver_gammaAt, METH_VARARGS, "FdmHestonSolver_gammaAt(FdmHestonSolver self, Real s, Real v) -> Real"},
	 { "FdmHestonSolver_meanVarianceDeltaAt", _wrap_FdmHestonSolver_meanVarianceDeltaAt, METH_VARARGS, "FdmHestonSolver_meanVarianceDeltaAt(FdmHestonSolver self, Real s, Real v) -> Real"},
	 { "FdmHestonSolver_meanVarianceGammaAt", _wrap_FdmHestonSolver_meanVarianceGammaAt, METH_VARARGS, "FdmHestonSolver_meanVarianceGammaAt(FdmHestonSolver self, Real s, Real v) -> Real"},
	 { "delete_FdmHestonSolver", _wrap_delete_FdmHestonSolver, METH_O, "delete_FdmHestonSolver(FdmHestonSolver self)"},
	 { "FdmHestonSolver_swigregister", FdmHestonSolver_swigregister, METH_O, NULL},
	 { "FdmHestonSolver_swiginit", FdmHestonSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmHullWhiteSolver", _wrap_new_FdmHullWhiteSolver, METH_VARARGS, "FdmHullWhiteSolver(ext::shared_ptr< HullWhite > const & model, FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())"},
	 { "FdmHullWhiteSolver_valueAt", _wrap_FdmHullWhiteSolver_valueAt, METH_VARARGS, "FdmHullWhiteSolver_valueAt(FdmHullWhiteSolver self, Real r) -> Real"},
	 { "delete_FdmHullWhiteSolver", _wrap_delete_FdmHullWhiteSolver, METH_O, "delete_FdmHullWhiteSolver(FdmHullWhiteSolver self)"},
	 { "FdmHullWhiteSolver_swigregister", FdmHullWhiteSolver_swigregister, METH_O, NULL},
	 { "FdmHullWhiteSolver_swiginit", FdmHullWhiteSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm4dimSolver", _wrap_new_Fdm4dimSolver, METH_VARARGS, "new_Fdm4dimSolver(FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm4dimSolver"},
	 { "Fdm4dimSolver_interpolateAt", _wrap_Fdm4dimSolver_interpolateAt, METH_VARARGS, "Fdm4dimSolver_interpolateAt(Fdm4dimSolver self, DoubleVector x) -> Real"},
	 { "Fdm4dimSolver_thetaAt", _wrap_Fdm4dimSolver_thetaAt, METH_VARARGS, "Fdm4dimSolver_thetaAt(Fdm4dimSolver self, DoubleVector x) -> Real"},
	 { "delete_Fdm4dimSolver", _wrap_delete_Fdm4dimSolver, METH_O, "delete_Fdm4dimSolver(Fdm4dimSolver self)"},
	 { "Fdm4dimSolver_swigregister", Fdm4dimSolver_swigregister, METH_O, NULL},
	 { "Fdm4dimSolver_swiginit", Fdm4dimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm5dimSolver", _wrap_new_Fdm5dimSolver, METH_VARARGS, "new_Fdm5dimSolver(FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm5dimSolver"},
	 { "Fdm5dimSolver_interpolateAt", _wrap_Fdm5dimSolver_interpolateAt, METH_VARARGS, "Fdm5dimSolver_interpolateAt(Fdm5dimSolver self, DoubleVector x) -> Real"},
	 { "Fdm5dimSolver_thetaAt", _wrap_Fdm5dimSolver_thetaAt, METH_VARARGS, "Fdm5dimSolver_thetaAt(Fdm5dimSolver self, DoubleVector x) -> Real"},
	 { "delete_Fdm5dimSolver", _wrap_delete_Fdm5dimSolver, METH_O, "delete_Fdm5dimSolver(Fdm5dimSolver self)"},
	 { "Fdm5dimSolver_swigregister", Fdm5dimSolver_swigregister, METH_O, NULL},
	 { "Fdm5dimSolver_swiginit", Fdm5dimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_Fdm6dimSolver", _wrap_new_Fdm6dimSolver, METH_VARARGS, "new_Fdm6dimSolver(FdmSolverDesc solverDesc, FdmSchemeDesc schemeDesc, ext::shared_ptr< FdmLinearOpComposite > const & op) -> Fdm6dimSolver"},
	 { "Fdm6dimSolver_interpolateAt", _wrap_Fdm6dimSolver_interpolateAt, METH_VARARGS, "Fdm6dimSolver_interpolateAt(Fdm6dimSolver self, DoubleVector x) -> Real"},
	 { "Fdm6dimSolver_thetaAt", _wrap_Fdm6dimSolver_thetaAt, METH_VARARGS, "Fdm6dimSolver_thetaAt(Fdm6dimSolver self, DoubleVector x) -> Real"},
	 { "delete_Fdm6dimSolver", _wrap_delete_Fdm6dimSolver, METH_O, "delete_Fdm6dimSolver(Fdm6dimSolver self)"},
	 { "Fdm6dimSolver_swigregister", Fdm6dimSolver_swigregister, METH_O, NULL},
	 { "Fdm6dimSolver_swiginit", Fdm6dimSolver_swiginit, METH_VARARGS, NULL},
	 { "new_FdmIndicesOnBoundary", _wrap_new_FdmIndicesOnBoundary, METH_VARARGS, "new_FdmIndicesOnBoundary(ext::shared_ptr< FdmLinearOpLayout > const & l, Size direction, FdmDirichletBoundary::Side side) -> FdmIndicesOnBoundary"},
	 { "FdmIndicesOnBoundary_getIndices", _wrap_FdmIndicesOnBoundary_getIndices, METH_O, "FdmIndicesOnBoundary_getIndices(FdmIndicesOnBoundary self) -> UnsignedIntVector"},
	 { "delete_FdmIndicesOnBoundary", _wrap_delete_FdmIndicesOnBoundary, METH_O, "delete_FdmIndicesOnBoundary(FdmIndicesOnBoundary self)"},
	 { "FdmIndicesOnBoundary_swigregister", FdmIndicesOnBoundary_swigregister, METH_O, NULL},
	 { "FdmIndicesOnBoundary_swiginit", FdmIndicesOnBoundary_swiginit, METH_VARARGS, NULL},
	 { "RiskNeutralDensityCalculator_pdf", _wrap_RiskNeutralDensityCalculator_pdf, METH_VARARGS, "RiskNeutralDensityCalculator_pdf(RiskNeutralDensityCalculator self, Real x, Time t) -> Real"},
	 { "RiskNeutralDensityCalculator_cdf", _wrap_RiskNeutralDensityCalculator_cdf, METH_VARARGS, "RiskNeutralDensityCalculator_cdf(RiskNeutralDensityCalculator self, Real x, Time t) -> Real"},
	 { "RiskNeutralDensityCalculator_invcdf", _wrap_RiskNeutralDensityCalculator_invcdf, METH_VARARGS, "RiskNeutralDensityCalculator_invcdf(RiskNeutralDensityCalculator self, Real p, Time t) -> Real"},
	 { "delete_RiskNeutralDensityCalculator", _wrap_delete_RiskNeutralDensityCalculator, METH_O, "delete_RiskNeutralDensityCalculator(RiskNeutralDensityCalculator self)"},
	 { "RiskNeutralDensityCalculator_swigregister", RiskNeutralDensityCalculator_swigregister, METH_O, NULL},
	 { "new_BSMRNDCalculator", _wrap_new_BSMRNDCalculator, METH_O, "new_BSMRNDCalculator(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> BSMRNDCalculator"},
	 { "delete_BSMRNDCalculator", _wrap_delete_BSMRNDCalculator, METH_O, "delete_BSMRNDCalculator(BSMRNDCalculator self)"},
	 { "BSMRNDCalculator_swigregister", BSMRNDCalculator_swigregister, METH_O, NULL},
	 { "BSMRNDCalculator_swiginit", BSMRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_CEVRNDCalculator", _wrap_new_CEVRNDCalculator, METH_VARARGS, "new_CEVRNDCalculator(Real f0, Real alpha, Real beta) -> CEVRNDCalculator"},
	 { "CEVRNDCalculator_massAtZero", _wrap_CEVRNDCalculator_massAtZero, METH_VARARGS, "CEVRNDCalculator_massAtZero(CEVRNDCalculator self, Time t) -> Real"},
	 { "delete_CEVRNDCalculator", _wrap_delete_CEVRNDCalculator, METH_O, "delete_CEVRNDCalculator(CEVRNDCalculator self)"},
	 { "CEVRNDCalculator_swigregister", CEVRNDCalculator_swigregister, METH_O, NULL},
	 { "CEVRNDCalculator_swiginit", CEVRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_GBSMRNDCalculator", _wrap_new_GBSMRNDCalculator, METH_O, "new_GBSMRNDCalculator(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> GBSMRNDCalculator"},
	 { "delete_GBSMRNDCalculator", _wrap_delete_GBSMRNDCalculator, METH_O, "delete_GBSMRNDCalculator(GBSMRNDCalculator self)"},
	 { "GBSMRNDCalculator_swigregister", GBSMRNDCalculator_swigregister, METH_O, NULL},
	 { "GBSMRNDCalculator_swiginit", GBSMRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_HestonRNDCalculator", _wrap_new_HestonRNDCalculator, METH_VARARGS, "HestonRNDCalculator(ext::shared_ptr< HestonProcess > const & hestonProcess, Real integrationEps=1e-6, Size maxIntegrationIterations=10000)"},
	 { "delete_HestonRNDCalculator", _wrap_delete_HestonRNDCalculator, METH_O, "delete_HestonRNDCalculator(HestonRNDCalculator self)"},
	 { "HestonRNDCalculator_swigregister", HestonRNDCalculator_swigregister, METH_O, NULL},
	 { "HestonRNDCalculator_swiginit", HestonRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_LocalVolRNDCalculator", (PyCFunction)(void(*)(void))_wrap_new_LocalVolRNDCalculator, METH_VARARGS|METH_KEYWORDS, "new_LocalVolRNDCalculator(ext::shared_ptr< Quote > const & spot, ext::shared_ptr< YieldTermStructure > const & rTS, ext::shared_ptr< YieldTermStructure > const & qTS, ext::shared_ptr< LocalVolTermStructure > const & localVol, Size xGrid=101, Size tGrid=51, Real x0Density=0.1, Real localVolProbEps=1e-6, Size maxIter=10000, Time gaussianStepSize=-Null< Time >()) -> LocalVolRNDCalculator"},
	 { "LocalVolRNDCalculator_mesher", _wrap_LocalVolRNDCalculator_mesher, METH_VARARGS, "LocalVolRNDCalculator_mesher(LocalVolRNDCalculator self, Time t) -> ext::shared_ptr< Fdm1dMesher >"},
	 { "LocalVolRNDCalculator_rescaleTimeSteps", _wrap_LocalVolRNDCalculator_rescaleTimeSteps, METH_O, "LocalVolRNDCalculator_rescaleTimeSteps(LocalVolRNDCalculator self) -> UnsignedIntVector"},
	 { "delete_LocalVolRNDCalculator", _wrap_delete_LocalVolRNDCalculator, METH_O, "delete_LocalVolRNDCalculator(LocalVolRNDCalculator self)"},
	 { "LocalVolRNDCalculator_swigregister", LocalVolRNDCalculator_swigregister, METH_O, NULL},
	 { "LocalVolRNDCalculator_swiginit", LocalVolRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "new_SquareRootProcessRNDCalculator", _wrap_new_SquareRootProcessRNDCalculator, METH_VARARGS, "new_SquareRootProcessRNDCalculator(Real v0, Real kappa, Real theta, Real sigma) -> SquareRootProcessRNDCalculator"},
	 { "SquareRootProcessRNDCalculator_stationary_pdf", _wrap_SquareRootProcessRNDCalculator_stationary_pdf, METH_VARARGS, "SquareRootProcessRNDCalculator_stationary_pdf(SquareRootProcessRNDCalculator self, Real v) -> Real"},
	 { "SquareRootProcessRNDCalculator_stationary_cdf", _wrap_SquareRootProcessRNDCalculator_stationary_cdf, METH_VARARGS, "SquareRootProcessRNDCalculator_stationary_cdf(SquareRootProcessRNDCalculator self, Real v) -> Real"},
	 { "SquareRootProcessRNDCalculator_stationary_invcdf", _wrap_SquareRootProcessRNDCalculator_stationary_invcdf, METH_VARARGS, "SquareRootProcessRNDCalculator_stationary_invcdf(SquareRootProcessRNDCalculator self, Real q) -> Real"},
	 { "delete_SquareRootProcessRNDCalculator", _wrap_delete_SquareRootProcessRNDCalculator, METH_O, "delete_SquareRootProcessRNDCalculator(SquareRootProcessRNDCalculator self)"},
	 { "SquareRootProcessRNDCalculator_swigregister", SquareRootProcessRNDCalculator_swigregister, METH_O, NULL},
	 { "SquareRootProcessRNDCalculator_swiginit", SquareRootProcessRNDCalculator_swiginit, METH_VARARGS, NULL},
	 { "delete_FittingMethod", _wrap_delete_FittingMethod, METH_O, "delete_FittingMethod(FittingMethod self)"},
	 { "FittingMethod_size", _wrap_FittingMethod_size, METH_O, "FittingMethod_size(FittingMethod self) -> Size"},
	 { "FittingMethod_solution", _wrap_FittingMethod_solution, METH_O, "FittingMethod_solution(FittingMethod self) -> Array"},
	 { "FittingMethod_numberOfIterations", _wrap_FittingMethod_numberOfIterations, METH_O, "FittingMethod_numberOfIterations(FittingMethod self) -> Integer"},
	 { "FittingMethod_minimumCostValue", _wrap_FittingMethod_minimumCostValue, METH_O, "FittingMethod_minimumCostValue(FittingMethod self) -> Real"},
	 { "FittingMethod_constrainAtZero", _wrap_FittingMethod_constrainAtZero, METH_O, "FittingMethod_constrainAtZero(FittingMethod self) -> bool"},
	 { "FittingMethod_weights", _wrap_FittingMethod_weights, METH_O, "FittingMethod_weights(FittingMethod self) -> Array"},
	 { "FittingMethod_swigregister", FittingMethod_swigregister, METH_O, NULL},
	 { "new_FittedBondDiscountCurve", _wrap_new_FittedBondDiscountCurve, METH_VARARGS, "\n"
		"FittedBondDiscountCurve(Natural settlementDays, Calendar calendar, BondHelperVector helpers, DayCounter dayCounter, FittingMethod fittingMethod, Real accuracy=1.0e-10, Size maxEvaluations=10000, Array guess=Array(), Real simplexLambda=1.0)\n"
		"FittedBondDiscountCurve(Date referenceDate, BondHelperVector helpers, DayCounter dayCounter, FittingMethod fittingMethod, Real accuracy=1.0e-10, Size maxEvaluations=10000, Array guess=Array(), Real simplexLambda=1.0)\n"
		""},
	 { "FittedBondDiscountCurve_fitResults", _wrap_FittedBondDiscountCurve_fitResults, METH_O, "FittedBondDiscountCurve_fitResults(FittedBondDiscountCurve self) -> FittingMethod"},
	 { "delete_FittedBondDiscountCurve", _wrap_delete_FittedBondDiscountCurve, METH_O, "delete_FittedBondDiscountCurve(FittedBondDiscountCurve self)"},
	 { "FittedBondDiscountCurve_swigregister", FittedBondDiscountCurve_swigregister, METH_O, NULL},
	 { "FittedBondDiscountCurve_swiginit", FittedBondDiscountCurve_swiginit, METH_VARARGS, NULL},
	 { "new_ExponentialSplinesFitting", _wrap_new_ExponentialSplinesFitting, METH_VARARGS, "ExponentialSplinesFitting(bool constrainAtZero=True, Array weights=Array(), Array l2=Array(), Real minCutoffTime=0.0, Real maxCutoffTime=QL_MAX_REAL, Size numCoeffs=9, Real fixedKappa=Null< Real >())"},
	 { "delete_ExponentialSplinesFitting", _wrap_delete_ExponentialSplinesFitting, METH_O, "delete_ExponentialSplinesFitting(ExponentialSplinesFitting self)"},
	 { "ExponentialSplinesFitting_swigregister", ExponentialSplinesFitting_swigregister, METH_O, NULL},
	 { "ExponentialSplinesFitting_swiginit", ExponentialSplinesFitting_swiginit, METH_VARARGS, NULL},
	 { "new_NelsonSiegelFitting", _wrap_new_NelsonSiegelFitting, METH_VARARGS, "NelsonSiegelFitting(Array weights=Array())"},
	 { "delete_NelsonSiegelFitting", _wrap_delete_NelsonSiegelFitting, METH_O, "delete_NelsonSiegelFitting(NelsonSiegelFitting self)"},
	 { "NelsonSiegelFitting_swigregister", NelsonSiegelFitting_swigregister, METH_O, NULL},
	 { "NelsonSiegelFitting_swiginit", NelsonSiegelFitting_swiginit, METH_VARARGS, NULL},
	 { "new_SvenssonFitting", _wrap_new_SvenssonFitting, METH_VARARGS, "SvenssonFitting(Array weights=Array())"},
	 { "delete_SvenssonFitting", _wrap_delete_SvenssonFitting, METH_O, "delete_SvenssonFitting(SvenssonFitting self)"},
	 { "SvenssonFitting_swigregister", SvenssonFitting_swigregister, METH_O, NULL},
	 { "SvenssonFitting_swiginit", SvenssonFitting_swiginit, METH_VARARGS, NULL},
	 { "new_CubicBSplinesFitting", _wrap_new_CubicBSplinesFitting, METH_VARARGS, "CubicBSplinesFitting(DoubleVector knotVector, bool constrainAtZero=True, Array weights=Array())"},
	 { "CubicBSplinesFitting_basisFunction", _wrap_CubicBSplinesFitting_basisFunction, METH_VARARGS, "CubicBSplinesFitting_basisFunction(CubicBSplinesFitting self, Integer i, Time t) -> Real"},
	 { "delete_CubicBSplinesFitting", _wrap_delete_CubicBSplinesFitting, METH_O, "delete_CubicBSplinesFitting(CubicBSplinesFitting self)"},
	 { "CubicBSplinesFitting_swigregister", CubicBSplinesFitting_swigregister, METH_O, NULL},
	 { "CubicBSplinesFitting_swiginit", CubicBSplinesFitting_swiginit, METH_VARARGS, NULL},
	 { "new_SimplePolynomialFitting", _wrap_new_SimplePolynomialFitting, METH_VARARGS, "SimplePolynomialFitting(Natural degree, bool constrainAtZero=True, Array weights=Array())"},
	 { "delete_SimplePolynomialFitting", _wrap_delete_SimplePolynomialFitting, METH_O, "delete_SimplePolynomialFitting(SimplePolynomialFitting self)"},
	 { "SimplePolynomialFitting_swigregister", SimplePolynomialFitting_swigregister, METH_O, NULL},
	 { "SimplePolynomialFitting_swiginit", SimplePolynomialFitting_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadFittingMethod", _wrap_new_SpreadFittingMethod, METH_VARARGS, "SpreadFittingMethod(ext::shared_ptr< FittingMethod > const & method, YieldTermStructureHandle discountCurve, Real minCutoffTime=0.0, Real maxCutoffTime=QL_MAX_REAL)"},
	 { "delete_SpreadFittingMethod", _wrap_delete_SpreadFittingMethod, METH_O, "delete_SpreadFittingMethod(SpreadFittingMethod self)"},
	 { "SpreadFittingMethod_swigregister", SpreadFittingMethod_swigregister, METH_O, NULL},
	 { "SpreadFittingMethod_swiginit", SpreadFittingMethod_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardCurve", _wrap_new_ForwardCurve, METH_VARARGS, "ForwardCurve(DateVector dates, DoubleVector forwards, DayCounter dayCounter, Calendar calendar=Calendar(), BackwardFlat i=BackwardFlat())"},
	 { "ForwardCurve_dates", _wrap_ForwardCurve_dates, METH_O, "ForwardCurve_dates(ForwardCurve self) -> DateVector"},
	 { "ForwardCurve_forwards", _wrap_ForwardCurve_forwards, METH_O, "ForwardCurve_forwards(ForwardCurve self) -> DoubleVector"},
	 { "ForwardCurve_nodes", _wrap_ForwardCurve_nodes, METH_O, "ForwardCurve_nodes(ForwardCurve self) -> NodeVector"},
	 { "delete_ForwardCurve", _wrap_delete_ForwardCurve, METH_O, "delete_ForwardCurve(ForwardCurve self)"},
	 { "ForwardCurve_swigregister", ForwardCurve_swigregister, METH_O, NULL},
	 { "ForwardCurve_swiginit", ForwardCurve_swiginit, METH_VARARGS, NULL},
	 { "new_Position", _wrap_new_Position, METH_NOARGS, "new_Position() -> Position"},
	 { "delete_Position", _wrap_delete_Position, METH_O, "delete_Position(Position self)"},
	 { "Position_swigregister", Position_swigregister, METH_O, NULL},
	 { "Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
	 { "new_ForwardRateAgreement", _wrap_new_ForwardRateAgreement, METH_VARARGS, "\n"
		"ForwardRateAgreement(Date valueDate, Date maturityDate, Position::Type type, Rate strikeForwardRate, Real notionalAmount, ext::shared_ptr< IborIndex > const & index, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), bool useIndexedCoupon=True)\n"
		"ForwardRateAgreement(Date valueDate, Position::Type type, Rate strikeForwardRate, Real notionalAmount, ext::shared_ptr< IborIndex > const & index, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >())\n"
		"ForwardRateAgreement(ext::shared_ptr< IborIndex > const & index, Date valueDate, Position::Type type, Rate strikeForwardRate, Real notionalAmount, YieldTermStructureHandle discountCurve={})\n"
		"ForwardRateAgreement(ext::shared_ptr< IborIndex > const & index, Date valueDate, Date maturityDate, Position::Type type, Rate strikeForwardRate, Real notionalAmount, YieldTermStructureHandle discountCurve={})\n"
		""},
	 { "ForwardRateAgreement_amount", _wrap_ForwardRateAgreement_amount, METH_O, "ForwardRateAgreement_amount(ForwardRateAgreement self) -> Real"},
	 { "ForwardRateAgreement_fixingDate", _wrap_ForwardRateAgreement_fixingDate, METH_O, "ForwardRateAgreement_fixingDate(ForwardRateAgreement self) -> Date"},
	 { "ForwardRateAgreement_forwardRate", _wrap_ForwardRateAgreement_forwardRate, METH_O, "ForwardRateAgreement_forwardRate(ForwardRateAgreement self) -> InterestRate"},
	 { "delete_ForwardRateAgreement", _wrap_delete_ForwardRateAgreement, METH_O, "delete_ForwardRateAgreement(ForwardRateAgreement self)"},
	 { "ForwardRateAgreement_swigregister", ForwardRateAgreement_swigregister, METH_O, NULL},
	 { "ForwardRateAgreement_swiginit", ForwardRateAgreement_swiginit, METH_VARARGS, NULL},
	 { "Gaussian1dModel_stateProcess", _wrap_Gaussian1dModel_stateProcess, METH_O, "Gaussian1dModel_stateProcess(Gaussian1dModel self) -> ext::shared_ptr< StochasticProcess1D > const"},
	 { "Gaussian1dModel_numeraire", _wrap_Gaussian1dModel_numeraire, METH_VARARGS, "\n"
		"Gaussian1dModel_numeraire(Gaussian1dModel self, Time const t, Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const\n"
		"Gaussian1dModel_numeraire(Gaussian1dModel self, Date referenceDate, Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const\n"
		""},
	 { "Gaussian1dModel_zerobond", _wrap_Gaussian1dModel_zerobond, METH_VARARGS, "\n"
		"Gaussian1dModel_zerobond(Gaussian1dModel self, Time const T, Time const t=0.0, Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const\n"
		"Gaussian1dModel_zerobond(Gaussian1dModel self, Date maturity, Date referenceDate=Null< Date >(), Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >()) -> Real const\n"
		""},
	 { "Gaussian1dModel_zerobondOption", _wrap_Gaussian1dModel_zerobondOption, METH_VARARGS, "Gaussian1dModel_zerobondOption(Gaussian1dModel self, Option::Type const & type, Date expiry, Date valueDate, Date maturity, Rate const strike, Date referenceDate=Null< Date >(), Real const y=0.0, YieldTermStructureHandle yts=Handle< YieldTermStructure >(), Real const yStdDevs=7.0, Size const yGridPoints=64, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False) -> Real const"},
	 { "Gaussian1dModel_forwardRate", _wrap_Gaussian1dModel_forwardRate, METH_VARARGS, "Gaussian1dModel_forwardRate(Gaussian1dModel self, Date fixing, Date referenceDate=Null< Date >(), Real const y=0.0, ext::shared_ptr< IborIndex > iborIdx=ext::shared_ptr< IborIndex >()) -> Real const"},
	 { "Gaussian1dModel_swapRate", _wrap_Gaussian1dModel_swapRate, METH_VARARGS, "Gaussian1dModel_swapRate(Gaussian1dModel self, Date fixing, Period tenor, Date referenceDate=Null< Date >(), Real const y=0.0, ext::shared_ptr< SwapIndex > swapIdx=ext::shared_ptr< SwapIndex >()) -> Real const"},
	 { "Gaussian1dModel_swapAnnuity", _wrap_Gaussian1dModel_swapAnnuity, METH_VARARGS, "Gaussian1dModel_swapAnnuity(Gaussian1dModel self, Date fixing, Period tenor, Date referenceDate=Null< Date >(), Real const y=0.0, ext::shared_ptr< SwapIndex > swapIdx=ext::shared_ptr< SwapIndex >()) -> Real const"},
	 { "delete_Gaussian1dModel", _wrap_delete_Gaussian1dModel, METH_O, "delete_Gaussian1dModel(Gaussian1dModel self)"},
	 { "Gaussian1dModel_swigregister", Gaussian1dModel_swigregister, METH_O, NULL},
	 { "new_Gsr", _wrap_new_Gsr, METH_VARARGS, "Gsr(YieldTermStructureHandle termStructure, DateVector volstepdates, QuoteHandleVector volatilities, QuoteHandleVector reversions, Real const T=60.0)"},
	 { "Gsr_calibrateVolatilitiesIterative", _wrap_Gsr_calibrateVolatilitiesIterative, METH_VARARGS, "Gsr_calibrateVolatilitiesIterative(Gsr self, BlackCalibrationHelperVector helpers, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >())"},
	 { "Gsr_reversion", _wrap_Gsr_reversion, METH_O, "Gsr_reversion(Gsr self) -> Array"},
	 { "Gsr_volatility", _wrap_Gsr_volatility, METH_O, "Gsr_volatility(Gsr self) -> Array"},
	 { "Gsr_params", _wrap_Gsr_params, METH_O, "Gsr_params(Gsr self) -> Array"},
	 { "Gsr_calibrate", _wrap_Gsr_calibrate, METH_VARARGS, "Gsr_calibrate(Gsr self, CalibrationHelperVector instruments, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"},
	 { "Gsr_setParams", _wrap_Gsr_setParams, METH_VARARGS, "Gsr_setParams(Gsr self, Array params)"},
	 { "Gsr_value", _wrap_Gsr_value, METH_VARARGS, "Gsr_value(Gsr self, Array params, CalibrationHelperVector instruments) -> Real"},
	 { "Gsr_constraint", _wrap_Gsr_constraint, METH_O, "Gsr_constraint(Gsr self) -> ext::shared_ptr< Constraint > const &"},
	 { "Gsr_endCriteria", _wrap_Gsr_endCriteria, METH_O, "Gsr_endCriteria(Gsr self) -> EndCriteria::Type"},
	 { "Gsr_problemValues", _wrap_Gsr_problemValues, METH_O, "Gsr_problemValues(Gsr self) -> Array"},
	 { "Gsr_functionEvaluation", _wrap_Gsr_functionEvaluation, METH_O, "Gsr_functionEvaluation(Gsr self) -> Integer"},
	 { "delete_Gsr", _wrap_delete_Gsr, METH_O, "delete_Gsr(Gsr self)"},
	 { "Gsr_swigregister", Gsr_swigregister, METH_O, NULL},
	 { "Gsr_swiginit", Gsr_swiginit, METH_VARARGS, NULL},
	 { "new_MarkovFunctional", _wrap_new_MarkovFunctional, METH_VARARGS, "\n"
		"MarkovFunctional(YieldTermStructureHandle termStructure, Real const reversion, DateVector volstepdates, DoubleVector volatilities, SwaptionVolatilityStructureHandle swaptionVol, DateVector swaptionExpiries, PeriodVector swaptionTenors, ext::shared_ptr< SwapIndex > const & swapIndexBase, MarkovFunctionalSettings modelSettings=MarkovFunctional::ModelSettings())\n"
		"MarkovFunctional(YieldTermStructureHandle termStructure, Real const reversion, DateVector volstepdates, DoubleVector volatilities, OptionletVolatilityStructureHandle capletVol, DateVector capletExpiries, ext::shared_ptr< IborIndex > const & iborIndex, MarkovFunctionalSettings modelSettings=MarkovFunctional::ModelSettings())\n"
		""},
	 { "MarkovFunctional_volatility", _wrap_MarkovFunctional_volatility, METH_O, "MarkovFunctional_volatility(MarkovFunctional self) -> Array"},
	 { "MarkovFunctional_calibrate", _wrap_MarkovFunctional_calibrate, METH_VARARGS, "MarkovFunctional_calibrate(MarkovFunctional self, CalibrationHelperVector helper, OptimizationMethod method, EndCriteria endCriteria, Constraint constraint=Constraint(), DoubleVector weights=std::vector< Real >(), BoolVector fixParameters=std::vector< bool >())"},
	 { "MarkovFunctional_params", _wrap_MarkovFunctional_params, METH_O, "MarkovFunctional_params(MarkovFunctional self) -> Array"},
	 { "MarkovFunctional_setParams", _wrap_MarkovFunctional_setParams, METH_VARARGS, "MarkovFunctional_setParams(MarkovFunctional self, Array params)"},
	 { "MarkovFunctional_value", _wrap_MarkovFunctional_value, METH_VARARGS, "MarkovFunctional_value(MarkovFunctional self, Array params, CalibrationHelperVector instruments) -> Real"},
	 { "MarkovFunctional_constraint", _wrap_MarkovFunctional_constraint, METH_O, "MarkovFunctional_constraint(MarkovFunctional self) -> ext::shared_ptr< Constraint > const &"},
	 { "MarkovFunctional_endCriteria", _wrap_MarkovFunctional_endCriteria, METH_O, "MarkovFunctional_endCriteria(MarkovFunctional self) -> EndCriteria::Type"},
	 { "MarkovFunctional_problemValues", _wrap_MarkovFunctional_problemValues, METH_O, "MarkovFunctional_problemValues(MarkovFunctional self) -> Array"},
	 { "MarkovFunctional_functionEvaluation", _wrap_MarkovFunctional_functionEvaluation, METH_O, "MarkovFunctional_functionEvaluation(MarkovFunctional self) -> Integer"},
	 { "delete_MarkovFunctional", _wrap_delete_MarkovFunctional, METH_O, "delete_MarkovFunctional(MarkovFunctional self)"},
	 { "MarkovFunctional_swigregister", MarkovFunctional_swigregister, METH_O, NULL},
	 { "MarkovFunctional_swiginit", MarkovFunctional_swiginit, METH_VARARGS, NULL},
	 { "new_MarkovFunctionalSettings", _wrap_new_MarkovFunctionalSettings, METH_VARARGS, "\n"
		"ModelSettings()\n"
		"ModelSettings(Size yGridPoints, Real yStdDevs, Size gaussHermitePoints, Real digitalGap, Real marketRateAccuracy, Real lowerRateBound, Real upperRateBound, int adjustments, DoubleVector smileMoneyCheckpoints=std::vector< Real >())\n"
		""},
	 { "MarkovFunctionalSettings_validate", _wrap_MarkovFunctionalSettings_validate, METH_O, "MarkovFunctionalSettings_validate(MarkovFunctionalSettings self)"},
	 { "delete_MarkovFunctionalSettings", _wrap_delete_MarkovFunctionalSettings, METH_O, "delete_MarkovFunctionalSettings(MarkovFunctionalSettings self)"},
	 { "MarkovFunctionalSettings_swigregister", MarkovFunctionalSettings_swigregister, METH_O, NULL},
	 { "MarkovFunctionalSettings_swiginit", MarkovFunctionalSettings_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dCapFloorEngine", _wrap_new_Gaussian1dCapFloorEngine, METH_VARARGS, "Gaussian1dCapFloorEngine(ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >())"},
	 { "delete_Gaussian1dCapFloorEngine", _wrap_delete_Gaussian1dCapFloorEngine, METH_O, "delete_Gaussian1dCapFloorEngine(Gaussian1dCapFloorEngine self)"},
	 { "Gaussian1dCapFloorEngine_swigregister", Gaussian1dCapFloorEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dCapFloorEngine_swiginit", Gaussian1dCapFloorEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dSwaptionEngine", _wrap_new_Gaussian1dSwaptionEngine, METH_VARARGS, "Gaussian1dSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), Gaussian1dSwaptionEngine::Probabilities const probabilities=NoProb)"},
	 { "delete_Gaussian1dSwaptionEngine", _wrap_delete_Gaussian1dSwaptionEngine, METH_O, "delete_Gaussian1dSwaptionEngine(Gaussian1dSwaptionEngine self)"},
	 { "Gaussian1dSwaptionEngine_swigregister", Gaussian1dSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dSwaptionEngine_swiginit", Gaussian1dSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dJamshidianSwaptionEngine", _wrap_new_Gaussian1dJamshidianSwaptionEngine, METH_O, "new_Gaussian1dJamshidianSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const & model) -> Gaussian1dJamshidianSwaptionEngine"},
	 { "delete_Gaussian1dJamshidianSwaptionEngine", _wrap_delete_Gaussian1dJamshidianSwaptionEngine, METH_O, "delete_Gaussian1dJamshidianSwaptionEngine(Gaussian1dJamshidianSwaptionEngine self)"},
	 { "Gaussian1dJamshidianSwaptionEngine_swigregister", Gaussian1dJamshidianSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dJamshidianSwaptionEngine_swiginit", Gaussian1dJamshidianSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dNonstandardSwaptionEngine", _wrap_new_Gaussian1dNonstandardSwaptionEngine, METH_VARARGS, "Gaussian1dNonstandardSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, QuoteHandle oas=Handle< Quote >(), YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), Gaussian1dNonstandardSwaptionEngine::Probabilities const probabilities=NoProb)"},
	 { "delete_Gaussian1dNonstandardSwaptionEngine", _wrap_delete_Gaussian1dNonstandardSwaptionEngine, METH_O, "delete_Gaussian1dNonstandardSwaptionEngine(Gaussian1dNonstandardSwaptionEngine self)"},
	 { "Gaussian1dNonstandardSwaptionEngine_swigregister", Gaussian1dNonstandardSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dNonstandardSwaptionEngine_swiginit", Gaussian1dNonstandardSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_Gaussian1dFloatFloatSwaptionEngine", _wrap_new_Gaussian1dFloatFloatSwaptionEngine, METH_VARARGS, "Gaussian1dFloatFloatSwaptionEngine(ext::shared_ptr< Gaussian1dModel > const & model, int const integrationPoints=64, Real const stddevs=7.0, bool const extrapolatePayoff=True, bool const flatPayoffExtrapolation=False, QuoteHandle oas=Handle< Quote >(), YieldTermStructureHandle discountCurve=Handle< YieldTermStructure >(), bool const includeTodaysExercise=False, Gaussian1dFloatFloatSwaptionEngine::Probabilities const probabilities=NoProb)"},
	 { "delete_Gaussian1dFloatFloatSwaptionEngine", _wrap_delete_Gaussian1dFloatFloatSwaptionEngine, METH_O, "delete_Gaussian1dFloatFloatSwaptionEngine(Gaussian1dFloatFloatSwaptionEngine self)"},
	 { "Gaussian1dFloatFloatSwaptionEngine_swigregister", Gaussian1dFloatFloatSwaptionEngine_swigregister, METH_O, NULL},
	 { "Gaussian1dFloatFloatSwaptionEngine_swiginit", Gaussian1dFloatFloatSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_SegmentIntegral", _wrap_new_SegmentIntegral, METH_O, "new_SegmentIntegral(Size intervals) -> SegmentIntegral"},
	 { "SegmentIntegral_numberOfEvaluations", _wrap_SegmentIntegral_numberOfEvaluations, METH_O, "SegmentIntegral_numberOfEvaluations(SegmentIntegral self) -> Size"},
	 { "SegmentIntegral___call__", _wrap_SegmentIntegral___call__, METH_VARARGS, "SegmentIntegral___call__(SegmentIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_SegmentIntegral", _wrap_delete_SegmentIntegral, METH_O, "delete_SegmentIntegral(SegmentIntegral self)"},
	 { "SegmentIntegral_swigregister", SegmentIntegral_swigregister, METH_O, NULL},
	 { "SegmentIntegral_swiginit", SegmentIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_TrapezoidIntegralDefault", _wrap_new_TrapezoidIntegralDefault, METH_VARARGS, "new_TrapezoidIntegralDefault(Real accuracy, Size maxIterations) -> TrapezoidIntegralDefault"},
	 { "TrapezoidIntegralDefault_numberOfEvaluations", _wrap_TrapezoidIntegralDefault_numberOfEvaluations, METH_O, "TrapezoidIntegralDefault_numberOfEvaluations(TrapezoidIntegralDefault self) -> Size"},
	 { "TrapezoidIntegralDefault___call__", _wrap_TrapezoidIntegralDefault___call__, METH_VARARGS, "TrapezoidIntegralDefault___call__(TrapezoidIntegralDefault self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_TrapezoidIntegralDefault", _wrap_delete_TrapezoidIntegralDefault, METH_O, "delete_TrapezoidIntegralDefault(TrapezoidIntegralDefault self)"},
	 { "TrapezoidIntegralDefault_swigregister", TrapezoidIntegralDefault_swigregister, METH_O, NULL},
	 { "TrapezoidIntegralDefault_swiginit", TrapezoidIntegralDefault_swiginit, METH_VARARGS, NULL},
	 { "new_TrapezoidIntegralMidPoint", _wrap_new_TrapezoidIntegralMidPoint, METH_VARARGS, "new_TrapezoidIntegralMidPoint(Real accuracy, Size maxIterations) -> TrapezoidIntegralMidPoint"},
	 { "TrapezoidIntegralMidPoint_numberOfEvaluations", _wrap_TrapezoidIntegralMidPoint_numberOfEvaluations, METH_O, "TrapezoidIntegralMidPoint_numberOfEvaluations(TrapezoidIntegralMidPoint self) -> Size"},
	 { "TrapezoidIntegralMidPoint___call__", _wrap_TrapezoidIntegralMidPoint___call__, METH_VARARGS, "TrapezoidIntegralMidPoint___call__(TrapezoidIntegralMidPoint self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_TrapezoidIntegralMidPoint", _wrap_delete_TrapezoidIntegralMidPoint, METH_O, "delete_TrapezoidIntegralMidPoint(TrapezoidIntegralMidPoint self)"},
	 { "TrapezoidIntegralMidPoint_swigregister", TrapezoidIntegralMidPoint_swigregister, METH_O, NULL},
	 { "TrapezoidIntegralMidPoint_swiginit", TrapezoidIntegralMidPoint_swiginit, METH_VARARGS, NULL},
	 { "new_SimpsonIntegral", _wrap_new_SimpsonIntegral, METH_VARARGS, "new_SimpsonIntegral(Real accuracy, Size maxIterations) -> SimpsonIntegral"},
	 { "SimpsonIntegral_numberOfEvaluations", _wrap_SimpsonIntegral_numberOfEvaluations, METH_O, "SimpsonIntegral_numberOfEvaluations(SimpsonIntegral self) -> Size"},
	 { "SimpsonIntegral___call__", _wrap_SimpsonIntegral___call__, METH_VARARGS, "SimpsonIntegral___call__(SimpsonIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_SimpsonIntegral", _wrap_delete_SimpsonIntegral, METH_O, "delete_SimpsonIntegral(SimpsonIntegral self)"},
	 { "SimpsonIntegral_swigregister", SimpsonIntegral_swigregister, METH_O, NULL},
	 { "SimpsonIntegral_swiginit", SimpsonIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_GaussKronrodAdaptive", _wrap_new_GaussKronrodAdaptive, METH_VARARGS, "GaussKronrodAdaptive(Real tolerance, Size maxFunctionEvaluations=Null< Size >())"},
	 { "GaussKronrodAdaptive_numberOfEvaluations", _wrap_GaussKronrodAdaptive_numberOfEvaluations, METH_O, "GaussKronrodAdaptive_numberOfEvaluations(GaussKronrodAdaptive self) -> Size"},
	 { "GaussKronrodAdaptive___call__", _wrap_GaussKronrodAdaptive___call__, METH_VARARGS, "GaussKronrodAdaptive___call__(GaussKronrodAdaptive self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_GaussKronrodAdaptive", _wrap_delete_GaussKronrodAdaptive, METH_O, "delete_GaussKronrodAdaptive(GaussKronrodAdaptive self)"},
	 { "GaussKronrodAdaptive_swigregister", GaussKronrodAdaptive_swigregister, METH_O, NULL},
	 { "GaussKronrodAdaptive_swiginit", GaussKronrodAdaptive_swiginit, METH_VARARGS, NULL},
	 { "new_GaussKronrodNonAdaptive", _wrap_new_GaussKronrodNonAdaptive, METH_VARARGS, "new_GaussKronrodNonAdaptive(Real absoluteAccuracy, Size maxEvaluations, Real relativeAccuracy) -> GaussKronrodNonAdaptive"},
	 { "GaussKronrodNonAdaptive_numberOfEvaluations", _wrap_GaussKronrodNonAdaptive_numberOfEvaluations, METH_O, "GaussKronrodNonAdaptive_numberOfEvaluations(GaussKronrodNonAdaptive self) -> Size"},
	 { "GaussKronrodNonAdaptive___call__", _wrap_GaussKronrodNonAdaptive___call__, METH_VARARGS, "GaussKronrodNonAdaptive___call__(GaussKronrodNonAdaptive self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_GaussKronrodNonAdaptive", _wrap_delete_GaussKronrodNonAdaptive, METH_O, "delete_GaussKronrodNonAdaptive(GaussKronrodNonAdaptive self)"},
	 { "GaussKronrodNonAdaptive_swigregister", GaussKronrodNonAdaptive_swigregister, METH_O, NULL},
	 { "GaussKronrodNonAdaptive_swiginit", GaussKronrodNonAdaptive_swiginit, METH_VARARGS, NULL},
	 { "new_GaussLobattoIntegral", _wrap_new_GaussLobattoIntegral, METH_VARARGS, "GaussLobattoIntegral(Size maxIterations, Real absAccuracy, Real relAccuracy=Null< Real >(), bool useConvergenceEstimate=True)"},
	 { "GaussLobattoIntegral_numberOfEvaluations", _wrap_GaussLobattoIntegral_numberOfEvaluations, METH_O, "GaussLobattoIntegral_numberOfEvaluations(GaussLobattoIntegral self) -> Size"},
	 { "GaussLobattoIntegral___call__", _wrap_GaussLobattoIntegral___call__, METH_VARARGS, "GaussLobattoIntegral___call__(GaussLobattoIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_GaussLobattoIntegral", _wrap_delete_GaussLobattoIntegral, METH_O, "delete_GaussLobattoIntegral(GaussLobattoIntegral self)"},
	 { "GaussLobattoIntegral_swigregister", GaussLobattoIntegral_swigregister, METH_O, NULL},
	 { "GaussLobattoIntegral_swiginit", GaussLobattoIntegral_swiginit, METH_VARARGS, NULL},
	 { "GaussianQuadrature_order", _wrap_GaussianQuadrature_order, METH_O, "GaussianQuadrature_order(GaussianQuadrature self) -> Size"},
	 { "GaussianQuadrature_weights", _wrap_GaussianQuadrature_weights, METH_O, "GaussianQuadrature_weights(GaussianQuadrature self) -> Array"},
	 { "GaussianQuadrature_x", _wrap_GaussianQuadrature_x, METH_O, "GaussianQuadrature_x(GaussianQuadrature self) -> Array"},
	 { "GaussianQuadrature___call__", _wrap_GaussianQuadrature___call__, METH_VARARGS, "GaussianQuadrature___call__(GaussianQuadrature self, PyObject * pyFunction) -> Real"},
	 { "delete_GaussianQuadrature", _wrap_delete_GaussianQuadrature, METH_O, "delete_GaussianQuadrature(GaussianQuadrature self)"},
	 { "GaussianQuadrature_swigregister", GaussianQuadrature_swigregister, METH_O, NULL},
	 { "new_GaussLaguerreIntegration", _wrap_new_GaussLaguerreIntegration, METH_VARARGS, "GaussLaguerreIntegration(Size n, Real s=0.0)"},
	 { "delete_GaussLaguerreIntegration", _wrap_delete_GaussLaguerreIntegration, METH_O, "delete_GaussLaguerreIntegration(GaussLaguerreIntegration self)"},
	 { "GaussLaguerreIntegration_swigregister", GaussLaguerreIntegration_swigregister, METH_O, NULL},
	 { "GaussLaguerreIntegration_swiginit", GaussLaguerreIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussHermiteIntegration", _wrap_new_GaussHermiteIntegration, METH_VARARGS, "GaussHermiteIntegration(Size n, Real mu=0.0)"},
	 { "delete_GaussHermiteIntegration", _wrap_delete_GaussHermiteIntegration, METH_O, "delete_GaussHermiteIntegration(GaussHermiteIntegration self)"},
	 { "GaussHermiteIntegration_swigregister", GaussHermiteIntegration_swigregister, METH_O, NULL},
	 { "GaussHermiteIntegration_swiginit", GaussHermiteIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussJacobiIntegration", _wrap_new_GaussJacobiIntegration, METH_VARARGS, "new_GaussJacobiIntegration(Size n, Real alpha, Real beta) -> GaussJacobiIntegration"},
	 { "delete_GaussJacobiIntegration", _wrap_delete_GaussJacobiIntegration, METH_O, "delete_GaussJacobiIntegration(GaussJacobiIntegration self)"},
	 { "GaussJacobiIntegration_swigregister", GaussJacobiIntegration_swigregister, METH_O, NULL},
	 { "GaussJacobiIntegration_swiginit", GaussJacobiIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussHyperbolicIntegration", _wrap_new_GaussHyperbolicIntegration, METH_O, "new_GaussHyperbolicIntegration(Size n) -> GaussHyperbolicIntegration"},
	 { "delete_GaussHyperbolicIntegration", _wrap_delete_GaussHyperbolicIntegration, METH_O, "delete_GaussHyperbolicIntegration(GaussHyperbolicIntegration self)"},
	 { "GaussHyperbolicIntegration_swigregister", GaussHyperbolicIntegration_swigregister, METH_O, NULL},
	 { "GaussHyperbolicIntegration_swiginit", GaussHyperbolicIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussLegendreIntegration", _wrap_new_GaussLegendreIntegration, METH_O, "new_GaussLegendreIntegration(Size n) -> GaussLegendreIntegration"},
	 { "delete_GaussLegendreIntegration", _wrap_delete_GaussLegendreIntegration, METH_O, "delete_GaussLegendreIntegration(GaussLegendreIntegration self)"},
	 { "GaussLegendreIntegration_swigregister", GaussLegendreIntegration_swigregister, METH_O, NULL},
	 { "GaussLegendreIntegration_swiginit", GaussLegendreIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussChebyshevIntegration", _wrap_new_GaussChebyshevIntegration, METH_O, "new_GaussChebyshevIntegration(Size n) -> GaussChebyshevIntegration"},
	 { "delete_GaussChebyshevIntegration", _wrap_delete_GaussChebyshevIntegration, METH_O, "delete_GaussChebyshevIntegration(GaussChebyshevIntegration self)"},
	 { "GaussChebyshevIntegration_swigregister", GaussChebyshevIntegration_swigregister, METH_O, NULL},
	 { "GaussChebyshevIntegration_swiginit", GaussChebyshevIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussChebyshev2ndIntegration", _wrap_new_GaussChebyshev2ndIntegration, METH_O, "new_GaussChebyshev2ndIntegration(Size n) -> GaussChebyshev2ndIntegration"},
	 { "delete_GaussChebyshev2ndIntegration", _wrap_delete_GaussChebyshev2ndIntegration, METH_O, "delete_GaussChebyshev2ndIntegration(GaussChebyshev2ndIntegration self)"},
	 { "GaussChebyshev2ndIntegration_swigregister", GaussChebyshev2ndIntegration_swigregister, METH_O, NULL},
	 { "GaussChebyshev2ndIntegration_swiginit", GaussChebyshev2ndIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_GaussGegenbauerIntegration", _wrap_new_GaussGegenbauerIntegration, METH_VARARGS, "new_GaussGegenbauerIntegration(Size n, Real lambda_parameter) -> GaussGegenbauerIntegration"},
	 { "delete_GaussGegenbauerIntegration", _wrap_delete_GaussGegenbauerIntegration, METH_O, "delete_GaussGegenbauerIntegration(GaussGegenbauerIntegration self)"},
	 { "GaussGegenbauerIntegration_swigregister", GaussGegenbauerIntegration_swigregister, METH_O, NULL},
	 { "GaussGegenbauerIntegration_swiginit", GaussGegenbauerIntegration_swiginit, METH_VARARGS, NULL},
	 { "new_TanhSinhIntegral", _wrap_new_TanhSinhIntegral, METH_VARARGS, "TanhSinhIntegral(Real relTolerance=std::sqrt(std::numeric_limits<Real>::epsilon()), Size maxRefinements=15, Real minComplement=std::numeric_limits< Real >::min()*4)"},
	 { "TanhSinhIntegral_numberOfEvaluations", _wrap_TanhSinhIntegral_numberOfEvaluations, METH_O, "TanhSinhIntegral_numberOfEvaluations(TanhSinhIntegral self) -> Size"},
	 { "TanhSinhIntegral___call__", _wrap_TanhSinhIntegral___call__, METH_VARARGS, "TanhSinhIntegral___call__(TanhSinhIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_TanhSinhIntegral", _wrap_delete_TanhSinhIntegral, METH_O, "delete_TanhSinhIntegral(TanhSinhIntegral self)"},
	 { "TanhSinhIntegral_swigregister", TanhSinhIntegral_swigregister, METH_O, NULL},
	 { "TanhSinhIntegral_swiginit", TanhSinhIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_ExpSinhIntegral", _wrap_new_ExpSinhIntegral, METH_VARARGS, "ExpSinhIntegral(Real relTolerance=std::sqrt(std::numeric_limits<Real>::epsilon()), Size maxRefinements=9)"},
	 { "ExpSinhIntegral_integrate", _wrap_ExpSinhIntegral_integrate, METH_VARARGS, "ExpSinhIntegral_integrate(ExpSinhIntegral self, PyObject * pyFunction) -> Real"},
	 { "ExpSinhIntegral_numberOfEvaluations", _wrap_ExpSinhIntegral_numberOfEvaluations, METH_O, "ExpSinhIntegral_numberOfEvaluations(ExpSinhIntegral self) -> Size"},
	 { "ExpSinhIntegral___call__", _wrap_ExpSinhIntegral___call__, METH_VARARGS, "ExpSinhIntegral___call__(ExpSinhIntegral self, PyObject * pyFunction, Real a, Real b) -> Real"},
	 { "delete_ExpSinhIntegral", _wrap_delete_ExpSinhIntegral, METH_O, "delete_ExpSinhIntegral(ExpSinhIntegral self)"},
	 { "ExpSinhIntegral_swigregister", ExpSinhIntegral_swigregister, METH_O, NULL},
	 { "ExpSinhIntegral_swiginit", ExpSinhIntegral_swiginit, METH_VARARGS, NULL},
	 { "new_LocalConstantVol", _wrap_new_LocalConstantVol, METH_VARARGS, "\n"
		"LocalConstantVol(Date referenceDate, Volatility volatility, DayCounter dayCounter)\n"
		"LocalConstantVol(Date referenceDate, QuoteHandle volatility, DayCounter dayCounter)\n"
		"LocalConstantVol(Integer settlementDays, Calendar calendar, Volatility volatility, DayCounter dayCounter)\n"
		"new_LocalConstantVol(Integer settlementDays, Calendar calendar, QuoteHandle volatility, DayCounter dayCounter) -> LocalConstantVol\n"
		""},
	 { "delete_LocalConstantVol", _wrap_delete_LocalConstantVol, METH_O, "delete_LocalConstantVol(LocalConstantVol self)"},
	 { "LocalConstantVol_swigregister", LocalConstantVol_swigregister, METH_O, NULL},
	 { "LocalConstantVol_swiginit", LocalConstantVol_swiginit, METH_VARARGS, NULL},
	 { "new_LocalVolSurface", _wrap_new_LocalVolSurface, METH_VARARGS, "\n"
		"LocalVolSurface(BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, QuoteHandle underlying)\n"
		"new_LocalVolSurface(BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, Real underlying) -> LocalVolSurface\n"
		""},
	 { "delete_LocalVolSurface", _wrap_delete_LocalVolSurface, METH_O, "delete_LocalVolSurface(LocalVolSurface self)"},
	 { "LocalVolSurface_swigregister", LocalVolSurface_swigregister, METH_O, NULL},
	 { "LocalVolSurface_swiginit", LocalVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_NoExceptLocalVolSurface", _wrap_new_NoExceptLocalVolSurface, METH_VARARGS, "\n"
		"NoExceptLocalVolSurface(BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, QuoteHandle underlying, Real illegalLocalVolOverwrite)\n"
		"new_NoExceptLocalVolSurface(BlackVolTermStructureHandle blackTS, YieldTermStructureHandle riskFreeTS, YieldTermStructureHandle dividendTS, Real underlying, Real illegalLocalVolOverwrite) -> NoExceptLocalVolSurface\n"
		""},
	 { "delete_NoExceptLocalVolSurface", _wrap_delete_NoExceptLocalVolSurface, METH_O, "delete_NoExceptLocalVolSurface(NoExceptLocalVolSurface self)"},
	 { "NoExceptLocalVolSurface_swigregister", NoExceptLocalVolSurface_swigregister, METH_O, NULL},
	 { "NoExceptLocalVolSurface_swiginit", NoExceptLocalVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_FixedLocalVolSurface", _wrap_new_FixedLocalVolSurface, METH_VARARGS, "\n"
		"FixedLocalVolSurface(Date referenceDate, DateVector dates, DoubleVector strikes, Matrix localVolMatrix, DayCounter dayCounter, FixedLocalVolSurface::Extrapolation lowerExtrapolation=ConstantExtrapolation, FixedLocalVolSurface::Extrapolation upperExtrapolation=ConstantExtrapolation)\n"
		"FixedLocalVolSurface(Date referenceDate, DoubleVector times, DoubleVector strikes, Matrix localVolMatrix, DayCounter dayCounter, FixedLocalVolSurface::Extrapolation lowerExtrapolation=ConstantExtrapolation, FixedLocalVolSurface::Extrapolation upperExtrapolation=ConstantExtrapolation)\n"
		"FixedLocalVolSurface(Date referenceDate, DoubleVector times, DoubleVectorVector strikes, Matrix localVolMatrix, DayCounter dayCounter, FixedLocalVolSurface::Extrapolation lowerExtrapolation=ConstantExtrapolation, FixedLocalVolSurface::Extrapolation upperExtrapolation=ConstantExtrapolation)\n"
		""},
	 { "FixedLocalVolSurface_setInterpolation", _wrap_FixedLocalVolSurface_setInterpolation, METH_VARARGS, "FixedLocalVolSurface_setInterpolation(FixedLocalVolSurface self, std::string const & interpolator=\"\")"},
	 { "delete_FixedLocalVolSurface", _wrap_delete_FixedLocalVolSurface, METH_O, "delete_FixedLocalVolSurface(FixedLocalVolSurface self)"},
	 { "FixedLocalVolSurface_swigregister", FixedLocalVolSurface_swigregister, METH_O, NULL},
	 { "FixedLocalVolSurface_swiginit", FixedLocalVolSurface_swiginit, METH_VARARGS, NULL},
	 { "new_GridModelLocalVolSurface", _wrap_new_GridModelLocalVolSurface, METH_VARARGS, "GridModelLocalVolSurface(Date referenceDate, DateVector dates, DoubleVectorVector strikes, DayCounter dayCounter, GridModelLocalVolSurface::Extrapolation lowerExtrapolation=ConstantExtrapolation, GridModelLocalVolSurface::Extrapolation upperExtrapolation=ConstantExtrapolation)"},
	 { "delete_GridModelLocalVolSurface", _wrap_delete_GridModelLocalVolSurface, METH_O, "delete_GridModelLocalVolSurface(GridModelLocalVolSurface self)"},
	 { "GridModelLocalVolSurface_swigregister", GridModelLocalVolSurface_swigregister, METH_O, NULL},
	 { "GridModelLocalVolSurface_swiginit", GridModelLocalVolSurface_swiginit, METH_VARARGS, NULL},
	 { "SampleNumber_value", _wrap_SampleNumber_value, METH_O, "SampleNumber_value(SampleNumber self) -> double const &"},
	 { "SampleNumber_weight", _wrap_SampleNumber_weight, METH_O, "SampleNumber_weight(SampleNumber self) -> Real"},
	 { "delete_SampleNumber", _wrap_delete_SampleNumber, METH_O, "delete_SampleNumber(SampleNumber self)"},
	 { "SampleNumber_swigregister", SampleNumber_swigregister, METH_O, NULL},
	 { "SampleArray_value", _wrap_SampleArray_value, METH_O, "SampleArray_value(SampleArray self) -> Array"},
	 { "SampleArray_weight", _wrap_SampleArray_weight, METH_O, "SampleArray_weight(SampleArray self) -> Real"},
	 { "delete_SampleArray", _wrap_delete_SampleArray, METH_O, "delete_SampleArray(SampleArray self)"},
	 { "SampleArray_swigregister", SampleArray_swigregister, METH_O, NULL},
	 { "SampleRealVector_value", _wrap_SampleRealVector_value, METH_O, "SampleRealVector_value(SampleRealVector self) -> DoubleVector"},
	 { "SampleRealVector_weight", _wrap_SampleRealVector_weight, METH_O, "SampleRealVector_weight(SampleRealVector self) -> Real"},
	 { "delete_SampleRealVector", _wrap_delete_SampleRealVector, METH_O, "delete_SampleRealVector(SampleRealVector self)"},
	 { "SampleRealVector_swigregister", SampleRealVector_swigregister, METH_O, NULL},
	 { "new_LecuyerUniformRng", _wrap_new_LecuyerUniformRng, METH_VARARGS, "LecuyerUniformRng(BigInteger seed=0)"},
	 { "LecuyerUniformRng_next", _wrap_LecuyerUniformRng_next, METH_O, "LecuyerUniformRng_next(LecuyerUniformRng self) -> SampleNumber"},
	 { "delete_LecuyerUniformRng", _wrap_delete_LecuyerUniformRng, METH_O, "delete_LecuyerUniformRng(LecuyerUniformRng self)"},
	 { "LecuyerUniformRng_swigregister", LecuyerUniformRng_swigregister, METH_O, NULL},
	 { "LecuyerUniformRng_swiginit", LecuyerUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_KnuthUniformRng", _wrap_new_KnuthUniformRng, METH_VARARGS, "KnuthUniformRng(BigInteger seed=0)"},
	 { "KnuthUniformRng_next", _wrap_KnuthUniformRng_next, METH_O, "KnuthUniformRng_next(KnuthUniformRng self) -> SampleNumber"},
	 { "delete_KnuthUniformRng", _wrap_delete_KnuthUniformRng, METH_O, "delete_KnuthUniformRng(KnuthUniformRng self)"},
	 { "KnuthUniformRng_swigregister", KnuthUniformRng_swigregister, METH_O, NULL},
	 { "KnuthUniformRng_swiginit", KnuthUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_MersenneTwisterUniformRng", _wrap_new_MersenneTwisterUniformRng, METH_VARARGS, "MersenneTwisterUniformRng(BigInteger seed=0)"},
	 { "MersenneTwisterUniformRng_next", _wrap_MersenneTwisterUniformRng_next, METH_O, "MersenneTwisterUniformRng_next(MersenneTwisterUniformRng self) -> SampleNumber"},
	 { "delete_MersenneTwisterUniformRng", _wrap_delete_MersenneTwisterUniformRng, METH_O, "delete_MersenneTwisterUniformRng(MersenneTwisterUniformRng self)"},
	 { "MersenneTwisterUniformRng_swigregister", MersenneTwisterUniformRng_swigregister, METH_O, NULL},
	 { "MersenneTwisterUniformRng_swiginit", MersenneTwisterUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_Xoshiro256StarStarUniformRng", _wrap_new_Xoshiro256StarStarUniformRng, METH_VARARGS, "Xoshiro256StarStarUniformRng(BigInteger seed=0)"},
	 { "Xoshiro256StarStarUniformRng_next", _wrap_Xoshiro256StarStarUniformRng_next, METH_O, "Xoshiro256StarStarUniformRng_next(Xoshiro256StarStarUniformRng self) -> SampleNumber"},
	 { "delete_Xoshiro256StarStarUniformRng", _wrap_delete_Xoshiro256StarStarUniformRng, METH_O, "delete_Xoshiro256StarStarUniformRng(Xoshiro256StarStarUniformRng self)"},
	 { "Xoshiro256StarStarUniformRng_swigregister", Xoshiro256StarStarUniformRng_swigregister, METH_O, NULL},
	 { "Xoshiro256StarStarUniformRng_swiginit", Xoshiro256StarStarUniformRng_swiginit, METH_VARARGS, NULL},
	 { "new_UniformRandomGenerator", _wrap_new_UniformRandomGenerator, METH_VARARGS, "UniformRandomGenerator(BigInteger seed=0)"},
	 { "UniformRandomGenerator_next", _wrap_UniformRandomGenerator_next, METH_O, "UniformRandomGenerator_next(UniformRandomGenerator self) -> SampleNumber"},
	 { "UniformRandomGenerator_nextValue", _wrap_UniformRandomGenerator_nextValue, METH_O, "UniformRandomGenerator_nextValue(UniformRandomGenerator self) -> Real"},
	 { "delete_UniformRandomGenerator", _wrap_delete_UniformRandomGenerator, METH_O, "delete_UniformRandomGenerator(UniformRandomGenerator self)"},
	 { "UniformRandomGenerator_swigregister", UniformRandomGenerator_swigregister, METH_O, NULL},
	 { "UniformRandomGenerator_swiginit", UniformRandomGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitLecuyerGaussianRng", _wrap_new_CentralLimitLecuyerGaussianRng, METH_O, "new_CentralLimitLecuyerGaussianRng(LecuyerUniformRng rng) -> CentralLimitLecuyerGaussianRng"},
	 { "CentralLimitLecuyerGaussianRng_next", _wrap_CentralLimitLecuyerGaussianRng_next, METH_O, "CentralLimitLecuyerGaussianRng_next(CentralLimitLecuyerGaussianRng self) -> SampleNumber"},
	 { "delete_CentralLimitLecuyerGaussianRng", _wrap_delete_CentralLimitLecuyerGaussianRng, METH_O, "delete_CentralLimitLecuyerGaussianRng(CentralLimitLecuyerGaussianRng self)"},
	 { "CentralLimitLecuyerGaussianRng_swigregister", CentralLimitLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitLecuyerGaussianRng_swiginit", CentralLimitLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitKnuthGaussianRng", _wrap_new_CentralLimitKnuthGaussianRng, METH_O, "new_CentralLimitKnuthGaussianRng(KnuthUniformRng rng) -> CentralLimitKnuthGaussianRng"},
	 { "CentralLimitKnuthGaussianRng_next", _wrap_CentralLimitKnuthGaussianRng_next, METH_O, "CentralLimitKnuthGaussianRng_next(CentralLimitKnuthGaussianRng self) -> SampleNumber"},
	 { "delete_CentralLimitKnuthGaussianRng", _wrap_delete_CentralLimitKnuthGaussianRng, METH_O, "delete_CentralLimitKnuthGaussianRng(CentralLimitKnuthGaussianRng self)"},
	 { "CentralLimitKnuthGaussianRng_swigregister", CentralLimitKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitKnuthGaussianRng_swiginit", CentralLimitKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitMersenneTwisterGaussianRng", _wrap_new_CentralLimitMersenneTwisterGaussianRng, METH_O, "new_CentralLimitMersenneTwisterGaussianRng(MersenneTwisterUniformRng rng) -> CentralLimitMersenneTwisterGaussianRng"},
	 { "CentralLimitMersenneTwisterGaussianRng_next", _wrap_CentralLimitMersenneTwisterGaussianRng_next, METH_O, "CentralLimitMersenneTwisterGaussianRng_next(CentralLimitMersenneTwisterGaussianRng self) -> SampleNumber"},
	 { "delete_CentralLimitMersenneTwisterGaussianRng", _wrap_delete_CentralLimitMersenneTwisterGaussianRng, METH_O, "delete_CentralLimitMersenneTwisterGaussianRng(CentralLimitMersenneTwisterGaussianRng self)"},
	 { "CentralLimitMersenneTwisterGaussianRng_swigregister", CentralLimitMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitMersenneTwisterGaussianRng_swiginit", CentralLimitMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_CentralLimitXoshiro256StarStarGaussianRng", _wrap_new_CentralLimitXoshiro256StarStarGaussianRng, METH_O, "new_CentralLimitXoshiro256StarStarGaussianRng(Xoshiro256StarStarUniformRng rng) -> CentralLimitXoshiro256StarStarGaussianRng"},
	 { "CentralLimitXoshiro256StarStarGaussianRng_next", _wrap_CentralLimitXoshiro256StarStarGaussianRng_next, METH_O, "CentralLimitXoshiro256StarStarGaussianRng_next(CentralLimitXoshiro256StarStarGaussianRng self) -> SampleNumber"},
	 { "delete_CentralLimitXoshiro256StarStarGaussianRng", _wrap_delete_CentralLimitXoshiro256StarStarGaussianRng, METH_O, "delete_CentralLimitXoshiro256StarStarGaussianRng(CentralLimitXoshiro256StarStarGaussianRng self)"},
	 { "CentralLimitXoshiro256StarStarGaussianRng_swigregister", CentralLimitXoshiro256StarStarGaussianRng_swigregister, METH_O, NULL},
	 { "CentralLimitXoshiro256StarStarGaussianRng_swiginit", CentralLimitXoshiro256StarStarGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerLecuyerGaussianRng", _wrap_new_BoxMullerLecuyerGaussianRng, METH_O, "new_BoxMullerLecuyerGaussianRng(LecuyerUniformRng rng) -> BoxMullerLecuyerGaussianRng"},
	 { "BoxMullerLecuyerGaussianRng_next", _wrap_BoxMullerLecuyerGaussianRng_next, METH_O, "BoxMullerLecuyerGaussianRng_next(BoxMullerLecuyerGaussianRng self) -> SampleNumber"},
	 { "delete_BoxMullerLecuyerGaussianRng", _wrap_delete_BoxMullerLecuyerGaussianRng, METH_O, "delete_BoxMullerLecuyerGaussianRng(BoxMullerLecuyerGaussianRng self)"},
	 { "BoxMullerLecuyerGaussianRng_swigregister", BoxMullerLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerLecuyerGaussianRng_swiginit", BoxMullerLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerKnuthGaussianRng", _wrap_new_BoxMullerKnuthGaussianRng, METH_O, "new_BoxMullerKnuthGaussianRng(KnuthUniformRng rng) -> BoxMullerKnuthGaussianRng"},
	 { "BoxMullerKnuthGaussianRng_next", _wrap_BoxMullerKnuthGaussianRng_next, METH_O, "BoxMullerKnuthGaussianRng_next(BoxMullerKnuthGaussianRng self) -> SampleNumber"},
	 { "delete_BoxMullerKnuthGaussianRng", _wrap_delete_BoxMullerKnuthGaussianRng, METH_O, "delete_BoxMullerKnuthGaussianRng(BoxMullerKnuthGaussianRng self)"},
	 { "BoxMullerKnuthGaussianRng_swigregister", BoxMullerKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerKnuthGaussianRng_swiginit", BoxMullerKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerMersenneTwisterGaussianRng", _wrap_new_BoxMullerMersenneTwisterGaussianRng, METH_O, "new_BoxMullerMersenneTwisterGaussianRng(MersenneTwisterUniformRng rng) -> BoxMullerMersenneTwisterGaussianRng"},
	 { "BoxMullerMersenneTwisterGaussianRng_next", _wrap_BoxMullerMersenneTwisterGaussianRng_next, METH_O, "BoxMullerMersenneTwisterGaussianRng_next(BoxMullerMersenneTwisterGaussianRng self) -> SampleNumber"},
	 { "delete_BoxMullerMersenneTwisterGaussianRng", _wrap_delete_BoxMullerMersenneTwisterGaussianRng, METH_O, "delete_BoxMullerMersenneTwisterGaussianRng(BoxMullerMersenneTwisterGaussianRng self)"},
	 { "BoxMullerMersenneTwisterGaussianRng_swigregister", BoxMullerMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerMersenneTwisterGaussianRng_swiginit", BoxMullerMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_BoxMullerXoshiro256StarStarGaussianRng", _wrap_new_BoxMullerXoshiro256StarStarGaussianRng, METH_O, "new_BoxMullerXoshiro256StarStarGaussianRng(Xoshiro256StarStarUniformRng rng) -> BoxMullerXoshiro256StarStarGaussianRng"},
	 { "BoxMullerXoshiro256StarStarGaussianRng_next", _wrap_BoxMullerXoshiro256StarStarGaussianRng_next, METH_O, "BoxMullerXoshiro256StarStarGaussianRng_next(BoxMullerXoshiro256StarStarGaussianRng self) -> SampleNumber"},
	 { "delete_BoxMullerXoshiro256StarStarGaussianRng", _wrap_delete_BoxMullerXoshiro256StarStarGaussianRng, METH_O, "delete_BoxMullerXoshiro256StarStarGaussianRng(BoxMullerXoshiro256StarStarGaussianRng self)"},
	 { "BoxMullerXoshiro256StarStarGaussianRng_swigregister", BoxMullerXoshiro256StarStarGaussianRng_swigregister, METH_O, NULL},
	 { "BoxMullerXoshiro256StarStarGaussianRng_swiginit", BoxMullerXoshiro256StarStarGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeLecuyerGaussianRng", _wrap_new_MoroInvCumulativeLecuyerGaussianRng, METH_O, "new_MoroInvCumulativeLecuyerGaussianRng(LecuyerUniformRng rng) -> MoroInvCumulativeLecuyerGaussianRng"},
	 { "MoroInvCumulativeLecuyerGaussianRng_next", _wrap_MoroInvCumulativeLecuyerGaussianRng_next, METH_O, "MoroInvCumulativeLecuyerGaussianRng_next(MoroInvCumulativeLecuyerGaussianRng self) -> SampleNumber"},
	 { "delete_MoroInvCumulativeLecuyerGaussianRng", _wrap_delete_MoroInvCumulativeLecuyerGaussianRng, METH_O, "delete_MoroInvCumulativeLecuyerGaussianRng(MoroInvCumulativeLecuyerGaussianRng self)"},
	 { "MoroInvCumulativeLecuyerGaussianRng_swigregister", MoroInvCumulativeLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRng_swiginit", MoroInvCumulativeLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeKnuthGaussianRng", _wrap_new_MoroInvCumulativeKnuthGaussianRng, METH_O, "new_MoroInvCumulativeKnuthGaussianRng(KnuthUniformRng rng) -> MoroInvCumulativeKnuthGaussianRng"},
	 { "MoroInvCumulativeKnuthGaussianRng_next", _wrap_MoroInvCumulativeKnuthGaussianRng_next, METH_O, "MoroInvCumulativeKnuthGaussianRng_next(MoroInvCumulativeKnuthGaussianRng self) -> SampleNumber"},
	 { "delete_MoroInvCumulativeKnuthGaussianRng", _wrap_delete_MoroInvCumulativeKnuthGaussianRng, METH_O, "delete_MoroInvCumulativeKnuthGaussianRng(MoroInvCumulativeKnuthGaussianRng self)"},
	 { "MoroInvCumulativeKnuthGaussianRng_swigregister", MoroInvCumulativeKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRng_swiginit", MoroInvCumulativeKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeMersenneTwisterGaussianRng", _wrap_new_MoroInvCumulativeMersenneTwisterGaussianRng, METH_O, "new_MoroInvCumulativeMersenneTwisterGaussianRng(MersenneTwisterUniformRng rng) -> MoroInvCumulativeMersenneTwisterGaussianRng"},
	 { "MoroInvCumulativeMersenneTwisterGaussianRng_next", _wrap_MoroInvCumulativeMersenneTwisterGaussianRng_next, METH_O, "MoroInvCumulativeMersenneTwisterGaussianRng_next(MoroInvCumulativeMersenneTwisterGaussianRng self) -> SampleNumber"},
	 { "delete_MoroInvCumulativeMersenneTwisterGaussianRng", _wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRng, METH_O, "delete_MoroInvCumulativeMersenneTwisterGaussianRng(MoroInvCumulativeMersenneTwisterGaussianRng self)"},
	 { "MoroInvCumulativeMersenneTwisterGaussianRng_swigregister", MoroInvCumulativeMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRng_swiginit", MoroInvCumulativeMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeXoshiro256StarStarGaussianRng", _wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRng, METH_O, "new_MoroInvCumulativeXoshiro256StarStarGaussianRng(Xoshiro256StarStarUniformRng rng) -> MoroInvCumulativeXoshiro256StarStarGaussianRng"},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRng_next", _wrap_MoroInvCumulativeXoshiro256StarStarGaussianRng_next, METH_O, "MoroInvCumulativeXoshiro256StarStarGaussianRng_next(MoroInvCumulativeXoshiro256StarStarGaussianRng self) -> SampleNumber"},
	 { "delete_MoroInvCumulativeXoshiro256StarStarGaussianRng", _wrap_delete_MoroInvCumulativeXoshiro256StarStarGaussianRng, METH_O, "delete_MoroInvCumulativeXoshiro256StarStarGaussianRng(MoroInvCumulativeXoshiro256StarStarGaussianRng self)"},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRng_swigregister", MoroInvCumulativeXoshiro256StarStarGaussianRng_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRng_swiginit", MoroInvCumulativeXoshiro256StarStarGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeLecuyerGaussianRng", _wrap_new_InvCumulativeLecuyerGaussianRng, METH_O, "new_InvCumulativeLecuyerGaussianRng(LecuyerUniformRng rng) -> InvCumulativeLecuyerGaussianRng"},
	 { "InvCumulativeLecuyerGaussianRng_next", _wrap_InvCumulativeLecuyerGaussianRng_next, METH_O, "InvCumulativeLecuyerGaussianRng_next(InvCumulativeLecuyerGaussianRng self) -> SampleNumber"},
	 { "delete_InvCumulativeLecuyerGaussianRng", _wrap_delete_InvCumulativeLecuyerGaussianRng, METH_O, "delete_InvCumulativeLecuyerGaussianRng(InvCumulativeLecuyerGaussianRng self)"},
	 { "InvCumulativeLecuyerGaussianRng_swigregister", InvCumulativeLecuyerGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRng_swiginit", InvCumulativeLecuyerGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeKnuthGaussianRng", _wrap_new_InvCumulativeKnuthGaussianRng, METH_O, "new_InvCumulativeKnuthGaussianRng(KnuthUniformRng rng) -> InvCumulativeKnuthGaussianRng"},
	 { "InvCumulativeKnuthGaussianRng_next", _wrap_InvCumulativeKnuthGaussianRng_next, METH_O, "InvCumulativeKnuthGaussianRng_next(InvCumulativeKnuthGaussianRng self) -> SampleNumber"},
	 { "delete_InvCumulativeKnuthGaussianRng", _wrap_delete_InvCumulativeKnuthGaussianRng, METH_O, "delete_InvCumulativeKnuthGaussianRng(InvCumulativeKnuthGaussianRng self)"},
	 { "InvCumulativeKnuthGaussianRng_swigregister", InvCumulativeKnuthGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRng_swiginit", InvCumulativeKnuthGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeMersenneTwisterGaussianRng", _wrap_new_InvCumulativeMersenneTwisterGaussianRng, METH_O, "new_InvCumulativeMersenneTwisterGaussianRng(MersenneTwisterUniformRng rng) -> InvCumulativeMersenneTwisterGaussianRng"},
	 { "InvCumulativeMersenneTwisterGaussianRng_next", _wrap_InvCumulativeMersenneTwisterGaussianRng_next, METH_O, "InvCumulativeMersenneTwisterGaussianRng_next(InvCumulativeMersenneTwisterGaussianRng self) -> SampleNumber"},
	 { "delete_InvCumulativeMersenneTwisterGaussianRng", _wrap_delete_InvCumulativeMersenneTwisterGaussianRng, METH_O, "delete_InvCumulativeMersenneTwisterGaussianRng(InvCumulativeMersenneTwisterGaussianRng self)"},
	 { "InvCumulativeMersenneTwisterGaussianRng_swigregister", InvCumulativeMersenneTwisterGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRng_swiginit", InvCumulativeMersenneTwisterGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeXoshiro256StarStarGaussianRng", _wrap_new_InvCumulativeXoshiro256StarStarGaussianRng, METH_O, "new_InvCumulativeXoshiro256StarStarGaussianRng(Xoshiro256StarStarUniformRng rng) -> InvCumulativeXoshiro256StarStarGaussianRng"},
	 { "InvCumulativeXoshiro256StarStarGaussianRng_next", _wrap_InvCumulativeXoshiro256StarStarGaussianRng_next, METH_O, "InvCumulativeXoshiro256StarStarGaussianRng_next(InvCumulativeXoshiro256StarStarGaussianRng self) -> SampleNumber"},
	 { "delete_InvCumulativeXoshiro256StarStarGaussianRng", _wrap_delete_InvCumulativeXoshiro256StarStarGaussianRng, METH_O, "delete_InvCumulativeXoshiro256StarStarGaussianRng(InvCumulativeXoshiro256StarStarGaussianRng self)"},
	 { "InvCumulativeXoshiro256StarStarGaussianRng_swigregister", InvCumulativeXoshiro256StarStarGaussianRng_swigregister, METH_O, NULL},
	 { "InvCumulativeXoshiro256StarStarGaussianRng_swiginit", InvCumulativeXoshiro256StarStarGaussianRng_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianRandomGenerator", _wrap_new_GaussianRandomGenerator, METH_O, "new_GaussianRandomGenerator(UniformRandomGenerator rng) -> GaussianRandomGenerator"},
	 { "GaussianRandomGenerator_next", _wrap_GaussianRandomGenerator_next, METH_O, "GaussianRandomGenerator_next(GaussianRandomGenerator self) -> SampleNumber"},
	 { "GaussianRandomGenerator_nextValue", _wrap_GaussianRandomGenerator_nextValue, METH_O, "GaussianRandomGenerator_nextValue(GaussianRandomGenerator self) -> Real"},
	 { "delete_GaussianRandomGenerator", _wrap_delete_GaussianRandomGenerator, METH_O, "delete_GaussianRandomGenerator(GaussianRandomGenerator self)"},
	 { "GaussianRandomGenerator_swigregister", GaussianRandomGenerator_swigregister, METH_O, NULL},
	 { "GaussianRandomGenerator_swiginit", GaussianRandomGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_HaltonRsg", _wrap_new_HaltonRsg, METH_VARARGS, "HaltonRsg(Size dimensionality, unsigned long seed=0, bool randomStart=True, bool randomShift=False)"},
	 { "HaltonRsg_nextSequence", _wrap_HaltonRsg_nextSequence, METH_O, "HaltonRsg_nextSequence(HaltonRsg self) -> SampleRealVector"},
	 { "HaltonRsg_lastSequence", _wrap_HaltonRsg_lastSequence, METH_O, "HaltonRsg_lastSequence(HaltonRsg self) -> SampleRealVector"},
	 { "HaltonRsg_dimension", _wrap_HaltonRsg_dimension, METH_O, "HaltonRsg_dimension(HaltonRsg self) -> Size"},
	 { "delete_HaltonRsg", _wrap_delete_HaltonRsg, METH_O, "delete_HaltonRsg(HaltonRsg self)"},
	 { "HaltonRsg_swigregister", HaltonRsg_swigregister, METH_O, NULL},
	 { "HaltonRsg_swiginit", HaltonRsg_swiginit, METH_VARARGS, NULL},
	 { "new_SobolRsg", _wrap_new_SobolRsg, METH_VARARGS, "SobolRsg(Size dimensionality, BigInteger seed=0, SobolRsg::DirectionIntegers directionIntegers=QuantLib::SobolRsg::Jaeckel)"},
	 { "SobolRsg_nextSequence", _wrap_SobolRsg_nextSequence, METH_O, "SobolRsg_nextSequence(SobolRsg self) -> SampleRealVector"},
	 { "SobolRsg_lastSequence", _wrap_SobolRsg_lastSequence, METH_O, "SobolRsg_lastSequence(SobolRsg self) -> SampleRealVector"},
	 { "SobolRsg_dimension", _wrap_SobolRsg_dimension, METH_O, "SobolRsg_dimension(SobolRsg self) -> Size"},
	 { "SobolRsg_skipTo", _wrap_SobolRsg_skipTo, METH_VARARGS, "SobolRsg_skipTo(SobolRsg self, Size n)"},
	 { "SobolRsg_nextInt32Sequence", _wrap_SobolRsg_nextInt32Sequence, METH_O, "SobolRsg_nextInt32Sequence(SobolRsg self) -> UnsignedIntVector"},
	 { "delete_SobolRsg", _wrap_delete_SobolRsg, METH_O, "delete_SobolRsg(SobolRsg self)"},
	 { "SobolRsg_swigregister", SobolRsg_swigregister, METH_O, NULL},
	 { "SobolRsg_swiginit", SobolRsg_swiginit, METH_VARARGS, NULL},
	 { "new_Burley2020SobolRsg", _wrap_new_Burley2020SobolRsg, METH_VARARGS, "Burley2020SobolRsg(Size dimensionality, BigInteger seed=42, SobolRsg::DirectionIntegers directionIntegers=QuantLib::SobolRsg::Jaeckel, BigInteger scrambleSeed=43)"},
	 { "Burley2020SobolRsg_nextSequence", _wrap_Burley2020SobolRsg_nextSequence, METH_O, "Burley2020SobolRsg_nextSequence(Burley2020SobolRsg self) -> SampleRealVector"},
	 { "Burley2020SobolRsg_lastSequence", _wrap_Burley2020SobolRsg_lastSequence, METH_O, "Burley2020SobolRsg_lastSequence(Burley2020SobolRsg self) -> SampleRealVector"},
	 { "Burley2020SobolRsg_dimension", _wrap_Burley2020SobolRsg_dimension, METH_O, "Burley2020SobolRsg_dimension(Burley2020SobolRsg self) -> Size"},
	 { "Burley2020SobolRsg_nextInt32Sequence", _wrap_Burley2020SobolRsg_nextInt32Sequence, METH_O, "Burley2020SobolRsg_nextInt32Sequence(Burley2020SobolRsg self) -> UnsignedIntVector"},
	 { "delete_Burley2020SobolRsg", _wrap_delete_Burley2020SobolRsg, METH_O, "delete_Burley2020SobolRsg(Burley2020SobolRsg self)"},
	 { "Burley2020SobolRsg_swigregister", Burley2020SobolRsg_swigregister, METH_O, NULL},
	 { "Burley2020SobolRsg_swiginit", Burley2020SobolRsg_swiginit, METH_VARARGS, NULL},
	 { "new_SobolBrownianBridgeRsg", _wrap_new_SobolBrownianBridgeRsg, METH_VARARGS, "new_SobolBrownianBridgeRsg(Size factors, Size steps) -> SobolBrownianBridgeRsg"},
	 { "SobolBrownianBridgeRsg_nextSequence", _wrap_SobolBrownianBridgeRsg_nextSequence, METH_O, "SobolBrownianBridgeRsg_nextSequence(SobolBrownianBridgeRsg self) -> SampleRealVector"},
	 { "SobolBrownianBridgeRsg_lastSequence", _wrap_SobolBrownianBridgeRsg_lastSequence, METH_O, "SobolBrownianBridgeRsg_lastSequence(SobolBrownianBridgeRsg self) -> SampleRealVector"},
	 { "SobolBrownianBridgeRsg_dimension", _wrap_SobolBrownianBridgeRsg_dimension, METH_O, "SobolBrownianBridgeRsg_dimension(SobolBrownianBridgeRsg self) -> Size"},
	 { "delete_SobolBrownianBridgeRsg", _wrap_delete_SobolBrownianBridgeRsg, METH_O, "delete_SobolBrownianBridgeRsg(SobolBrownianBridgeRsg self)"},
	 { "SobolBrownianBridgeRsg_swigregister", SobolBrownianBridgeRsg_swigregister, METH_O, NULL},
	 { "SobolBrownianBridgeRsg_swiginit", SobolBrownianBridgeRsg_swiginit, METH_VARARGS, NULL},
	 { "new_Burley2020SobolBrownianBridgeRsg", _wrap_new_Burley2020SobolBrownianBridgeRsg, METH_VARARGS, "new_Burley2020SobolBrownianBridgeRsg(Size factors, Size steps) -> Burley2020SobolBrownianBridgeRsg"},
	 { "Burley2020SobolBrownianBridgeRsg_nextSequence", _wrap_Burley2020SobolBrownianBridgeRsg_nextSequence, METH_O, "Burley2020SobolBrownianBridgeRsg_nextSequence(Burley2020SobolBrownianBridgeRsg self) -> SampleRealVector"},
	 { "Burley2020SobolBrownianBridgeRsg_lastSequence", _wrap_Burley2020SobolBrownianBridgeRsg_lastSequence, METH_O, "Burley2020SobolBrownianBridgeRsg_lastSequence(Burley2020SobolBrownianBridgeRsg self) -> SampleRealVector"},
	 { "Burley2020SobolBrownianBridgeRsg_dimension", _wrap_Burley2020SobolBrownianBridgeRsg_dimension, METH_O, "Burley2020SobolBrownianBridgeRsg_dimension(Burley2020SobolBrownianBridgeRsg self) -> Size"},
	 { "delete_Burley2020SobolBrownianBridgeRsg", _wrap_delete_Burley2020SobolBrownianBridgeRsg, METH_O, "delete_Burley2020SobolBrownianBridgeRsg(Burley2020SobolBrownianBridgeRsg self)"},
	 { "Burley2020SobolBrownianBridgeRsg_swigregister", Burley2020SobolBrownianBridgeRsg_swigregister, METH_O, NULL},
	 { "Burley2020SobolBrownianBridgeRsg_swiginit", Burley2020SobolBrownianBridgeRsg_swiginit, METH_VARARGS, NULL},
	 { "new_LecuyerUniformRsg", _wrap_new_LecuyerUniformRsg, METH_VARARGS, "\n"
		"LecuyerUniformRsg(Size dimensionality, LecuyerUniformRng rng)\n"
		"LecuyerUniformRsg(Size dimensionality, BigNatural seed=0)\n"
		""},
	 { "LecuyerUniformRsg_nextSequence", _wrap_LecuyerUniformRsg_nextSequence, METH_O, "LecuyerUniformRsg_nextSequence(LecuyerUniformRsg self) -> SampleRealVector"},
	 { "LecuyerUniformRsg_dimension", _wrap_LecuyerUniformRsg_dimension, METH_O, "LecuyerUniformRsg_dimension(LecuyerUniformRsg self) -> Size"},
	 { "delete_LecuyerUniformRsg", _wrap_delete_LecuyerUniformRsg, METH_O, "delete_LecuyerUniformRsg(LecuyerUniformRsg self)"},
	 { "LecuyerUniformRsg_swigregister", LecuyerUniformRsg_swigregister, METH_O, NULL},
	 { "LecuyerUniformRsg_swiginit", LecuyerUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_KnuthUniformRsg", _wrap_new_KnuthUniformRsg, METH_VARARGS, "\n"
		"KnuthUniformRsg(Size dimensionality, KnuthUniformRng rng)\n"
		"KnuthUniformRsg(Size dimensionality, BigNatural seed=0)\n"
		""},
	 { "KnuthUniformRsg_nextSequence", _wrap_KnuthUniformRsg_nextSequence, METH_O, "KnuthUniformRsg_nextSequence(KnuthUniformRsg self) -> SampleRealVector"},
	 { "KnuthUniformRsg_dimension", _wrap_KnuthUniformRsg_dimension, METH_O, "KnuthUniformRsg_dimension(KnuthUniformRsg self) -> Size"},
	 { "delete_KnuthUniformRsg", _wrap_delete_KnuthUniformRsg, METH_O, "delete_KnuthUniformRsg(KnuthUniformRsg self)"},
	 { "KnuthUniformRsg_swigregister", KnuthUniformRsg_swigregister, METH_O, NULL},
	 { "KnuthUniformRsg_swiginit", KnuthUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MersenneTwisterUniformRsg", _wrap_new_MersenneTwisterUniformRsg, METH_VARARGS, "\n"
		"MersenneTwisterUniformRsg(Size dimensionality, MersenneTwisterUniformRng rng)\n"
		"MersenneTwisterUniformRsg(Size dimensionality, BigNatural seed=0)\n"
		""},
	 { "MersenneTwisterUniformRsg_nextSequence", _wrap_MersenneTwisterUniformRsg_nextSequence, METH_O, "MersenneTwisterUniformRsg_nextSequence(MersenneTwisterUniformRsg self) -> SampleRealVector"},
	 { "MersenneTwisterUniformRsg_dimension", _wrap_MersenneTwisterUniformRsg_dimension, METH_O, "MersenneTwisterUniformRsg_dimension(MersenneTwisterUniformRsg self) -> Size"},
	 { "delete_MersenneTwisterUniformRsg", _wrap_delete_MersenneTwisterUniformRsg, METH_O, "delete_MersenneTwisterUniformRsg(MersenneTwisterUniformRsg self)"},
	 { "MersenneTwisterUniformRsg_swigregister", MersenneTwisterUniformRsg_swigregister, METH_O, NULL},
	 { "MersenneTwisterUniformRsg_swiginit", MersenneTwisterUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_Xoshiro256StarStarUniformRsg", _wrap_new_Xoshiro256StarStarUniformRsg, METH_VARARGS, "\n"
		"Xoshiro256StarStarUniformRsg(Size dimensionality, Xoshiro256StarStarUniformRng rng)\n"
		"Xoshiro256StarStarUniformRsg(Size dimensionality, BigNatural seed=0)\n"
		""},
	 { "Xoshiro256StarStarUniformRsg_nextSequence", _wrap_Xoshiro256StarStarUniformRsg_nextSequence, METH_O, "Xoshiro256StarStarUniformRsg_nextSequence(Xoshiro256StarStarUniformRsg self) -> SampleRealVector"},
	 { "Xoshiro256StarStarUniformRsg_dimension", _wrap_Xoshiro256StarStarUniformRsg_dimension, METH_O, "Xoshiro256StarStarUniformRsg_dimension(Xoshiro256StarStarUniformRsg self) -> Size"},
	 { "delete_Xoshiro256StarStarUniformRsg", _wrap_delete_Xoshiro256StarStarUniformRsg, METH_O, "delete_Xoshiro256StarStarUniformRsg(Xoshiro256StarStarUniformRsg self)"},
	 { "Xoshiro256StarStarUniformRsg_swigregister", Xoshiro256StarStarUniformRsg_swigregister, METH_O, NULL},
	 { "Xoshiro256StarStarUniformRsg_swiginit", Xoshiro256StarStarUniformRsg_swiginit, METH_VARARGS, NULL},
	 { "new_UniformRandomSequenceGenerator", _wrap_new_UniformRandomSequenceGenerator, METH_VARARGS, "new_UniformRandomSequenceGenerator(Size dimensionality, UniformRandomGenerator rng) -> UniformRandomSequenceGenerator"},
	 { "UniformRandomSequenceGenerator_nextSequence", _wrap_UniformRandomSequenceGenerator_nextSequence, METH_O, "UniformRandomSequenceGenerator_nextSequence(UniformRandomSequenceGenerator self) -> SampleRealVector"},
	 { "UniformRandomSequenceGenerator_dimension", _wrap_UniformRandomSequenceGenerator_dimension, METH_O, "UniformRandomSequenceGenerator_dimension(UniformRandomSequenceGenerator self) -> Size"},
	 { "delete_UniformRandomSequenceGenerator", _wrap_delete_UniformRandomSequenceGenerator, METH_O, "delete_UniformRandomSequenceGenerator(UniformRandomSequenceGenerator self)"},
	 { "UniformRandomSequenceGenerator_swigregister", UniformRandomSequenceGenerator_swigregister, METH_O, NULL},
	 { "UniformRandomSequenceGenerator_swiginit", UniformRandomSequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_UniformLowDiscrepancySequenceGenerator", _wrap_new_UniformLowDiscrepancySequenceGenerator, METH_VARARGS, "UniformLowDiscrepancySequenceGenerator(Size dimensionality, BigInteger seed=0, SobolRsg::DirectionIntegers directionIntegers=QuantLib::SobolRsg::Jaeckel)"},
	 { "UniformLowDiscrepancySequenceGenerator_nextSequence", _wrap_UniformLowDiscrepancySequenceGenerator_nextSequence, METH_O, "UniformLowDiscrepancySequenceGenerator_nextSequence(UniformLowDiscrepancySequenceGenerator self) -> SampleRealVector"},
	 { "UniformLowDiscrepancySequenceGenerator_dimension", _wrap_UniformLowDiscrepancySequenceGenerator_dimension, METH_O, "UniformLowDiscrepancySequenceGenerator_dimension(UniformLowDiscrepancySequenceGenerator self) -> Size"},
	 { "delete_UniformLowDiscrepancySequenceGenerator", _wrap_delete_UniformLowDiscrepancySequenceGenerator, METH_O, "delete_UniformLowDiscrepancySequenceGenerator(UniformLowDiscrepancySequenceGenerator self)"},
	 { "UniformLowDiscrepancySequenceGenerator_swigregister", UniformLowDiscrepancySequenceGenerator_swigregister, METH_O, NULL},
	 { "UniformLowDiscrepancySequenceGenerator_swiginit", UniformLowDiscrepancySequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeLecuyerGaussianRsg", _wrap_new_MoroInvCumulativeLecuyerGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeLecuyerGaussianRsg(LecuyerUniformRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeLecuyerGaussianRsg(LecuyerUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeLecuyerGaussianRsg\n"
		""},
	 { "MoroInvCumulativeLecuyerGaussianRsg_nextSequence", _wrap_MoroInvCumulativeLecuyerGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeLecuyerGaussianRsg_nextSequence(MoroInvCumulativeLecuyerGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeLecuyerGaussianRsg_dimension", _wrap_MoroInvCumulativeLecuyerGaussianRsg_dimension, METH_O, "MoroInvCumulativeLecuyerGaussianRsg_dimension(MoroInvCumulativeLecuyerGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeLecuyerGaussianRsg", _wrap_delete_MoroInvCumulativeLecuyerGaussianRsg, METH_O, "delete_MoroInvCumulativeLecuyerGaussianRsg(MoroInvCumulativeLecuyerGaussianRsg self)"},
	 { "MoroInvCumulativeLecuyerGaussianRsg_swigregister", MoroInvCumulativeLecuyerGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeLecuyerGaussianRsg_swiginit", MoroInvCumulativeLecuyerGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeKnuthGaussianRsg", _wrap_new_MoroInvCumulativeKnuthGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeKnuthGaussianRsg(KnuthUniformRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeKnuthGaussianRsg(KnuthUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeKnuthGaussianRsg\n"
		""},
	 { "MoroInvCumulativeKnuthGaussianRsg_nextSequence", _wrap_MoroInvCumulativeKnuthGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeKnuthGaussianRsg_nextSequence(MoroInvCumulativeKnuthGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeKnuthGaussianRsg_dimension", _wrap_MoroInvCumulativeKnuthGaussianRsg_dimension, METH_O, "MoroInvCumulativeKnuthGaussianRsg_dimension(MoroInvCumulativeKnuthGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeKnuthGaussianRsg", _wrap_delete_MoroInvCumulativeKnuthGaussianRsg, METH_O, "delete_MoroInvCumulativeKnuthGaussianRsg(MoroInvCumulativeKnuthGaussianRsg self)"},
	 { "MoroInvCumulativeKnuthGaussianRsg_swigregister", MoroInvCumulativeKnuthGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeKnuthGaussianRsg_swiginit", MoroInvCumulativeKnuthGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeMersenneTwisterGaussianRsg", _wrap_new_MoroInvCumulativeMersenneTwisterGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeMersenneTwisterGaussianRsg(MersenneTwisterUniformRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeMersenneTwisterGaussianRsg(MersenneTwisterUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeMersenneTwisterGaussianRsg\n"
		""},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence", _wrap_MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeMersenneTwisterGaussianRsg_nextSequence(MoroInvCumulativeMersenneTwisterGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_dimension", _wrap_MoroInvCumulativeMersenneTwisterGaussianRsg_dimension, METH_O, "MoroInvCumulativeMersenneTwisterGaussianRsg_dimension(MoroInvCumulativeMersenneTwisterGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeMersenneTwisterGaussianRsg", _wrap_delete_MoroInvCumulativeMersenneTwisterGaussianRsg, METH_O, "delete_MoroInvCumulativeMersenneTwisterGaussianRsg(MoroInvCumulativeMersenneTwisterGaussianRsg self)"},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister", MoroInvCumulativeMersenneTwisterGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit", MoroInvCumulativeMersenneTwisterGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeXoshiro256StarStarGaussianRsg", _wrap_new_MoroInvCumulativeXoshiro256StarStarGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeXoshiro256StarStarGaussianRsg(Xoshiro256StarStarUniformRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeXoshiro256StarStarGaussianRsg(Xoshiro256StarStarUniformRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeXoshiro256StarStarGaussianRsg\n"
		""},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRsg_nextSequence", _wrap_MoroInvCumulativeXoshiro256StarStarGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeXoshiro256StarStarGaussianRsg_nextSequence(MoroInvCumulativeXoshiro256StarStarGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRsg_dimension", _wrap_MoroInvCumulativeXoshiro256StarStarGaussianRsg_dimension, METH_O, "MoroInvCumulativeXoshiro256StarStarGaussianRsg_dimension(MoroInvCumulativeXoshiro256StarStarGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeXoshiro256StarStarGaussianRsg", _wrap_delete_MoroInvCumulativeXoshiro256StarStarGaussianRsg, METH_O, "delete_MoroInvCumulativeXoshiro256StarStarGaussianRsg(MoroInvCumulativeXoshiro256StarStarGaussianRsg self)"},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRsg_swigregister", MoroInvCumulativeXoshiro256StarStarGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeXoshiro256StarStarGaussianRsg_swiginit", MoroInvCumulativeXoshiro256StarStarGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeHaltonGaussianRsg", _wrap_new_MoroInvCumulativeHaltonGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeHaltonGaussianRsg(HaltonRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeHaltonGaussianRsg(HaltonRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeHaltonGaussianRsg\n"
		""},
	 { "MoroInvCumulativeHaltonGaussianRsg_nextSequence", _wrap_MoroInvCumulativeHaltonGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeHaltonGaussianRsg_nextSequence(MoroInvCumulativeHaltonGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeHaltonGaussianRsg_dimension", _wrap_MoroInvCumulativeHaltonGaussianRsg_dimension, METH_O, "MoroInvCumulativeHaltonGaussianRsg_dimension(MoroInvCumulativeHaltonGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeHaltonGaussianRsg", _wrap_delete_MoroInvCumulativeHaltonGaussianRsg, METH_O, "delete_MoroInvCumulativeHaltonGaussianRsg(MoroInvCumulativeHaltonGaussianRsg self)"},
	 { "MoroInvCumulativeHaltonGaussianRsg_swigregister", MoroInvCumulativeHaltonGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeHaltonGaussianRsg_swiginit", MoroInvCumulativeHaltonGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeSobolGaussianRsg", _wrap_new_MoroInvCumulativeSobolGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeSobolGaussianRsg(SobolRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeSobolGaussianRsg(SobolRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeSobolGaussianRsg\n"
		""},
	 { "MoroInvCumulativeSobolGaussianRsg_nextSequence", _wrap_MoroInvCumulativeSobolGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeSobolGaussianRsg_nextSequence(MoroInvCumulativeSobolGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeSobolGaussianRsg_dimension", _wrap_MoroInvCumulativeSobolGaussianRsg_dimension, METH_O, "MoroInvCumulativeSobolGaussianRsg_dimension(MoroInvCumulativeSobolGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeSobolGaussianRsg", _wrap_delete_MoroInvCumulativeSobolGaussianRsg, METH_O, "delete_MoroInvCumulativeSobolGaussianRsg(MoroInvCumulativeSobolGaussianRsg self)"},
	 { "MoroInvCumulativeSobolGaussianRsg_swigregister", MoroInvCumulativeSobolGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeSobolGaussianRsg_swiginit", MoroInvCumulativeSobolGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_MoroInvCumulativeBurley2020SobolGaussianRsg", _wrap_new_MoroInvCumulativeBurley2020SobolGaussianRsg, METH_VARARGS, "\n"
		"MoroInvCumulativeBurley2020SobolGaussianRsg(Burley2020SobolRsg uniformSequenceGenerator)\n"
		"new_MoroInvCumulativeBurley2020SobolGaussianRsg(Burley2020SobolRsg uniformSequenceGenerator, MoroInverseCumulativeNormal inverseCumulative) -> MoroInvCumulativeBurley2020SobolGaussianRsg\n"
		""},
	 { "MoroInvCumulativeBurley2020SobolGaussianRsg_nextSequence", _wrap_MoroInvCumulativeBurley2020SobolGaussianRsg_nextSequence, METH_O, "MoroInvCumulativeBurley2020SobolGaussianRsg_nextSequence(MoroInvCumulativeBurley2020SobolGaussianRsg self) -> SampleRealVector"},
	 { "MoroInvCumulativeBurley2020SobolGaussianRsg_dimension", _wrap_MoroInvCumulativeBurley2020SobolGaussianRsg_dimension, METH_O, "MoroInvCumulativeBurley2020SobolGaussianRsg_dimension(MoroInvCumulativeBurley2020SobolGaussianRsg self) -> Size"},
	 { "delete_MoroInvCumulativeBurley2020SobolGaussianRsg", _wrap_delete_MoroInvCumulativeBurley2020SobolGaussianRsg, METH_O, "delete_MoroInvCumulativeBurley2020SobolGaussianRsg(MoroInvCumulativeBurley2020SobolGaussianRsg self)"},
	 { "MoroInvCumulativeBurley2020SobolGaussianRsg_swigregister", MoroInvCumulativeBurley2020SobolGaussianRsg_swigregister, METH_O, NULL},
	 { "MoroInvCumulativeBurley2020SobolGaussianRsg_swiginit", MoroInvCumulativeBurley2020SobolGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeLecuyerGaussianRsg", _wrap_new_InvCumulativeLecuyerGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeLecuyerGaussianRsg(LecuyerUniformRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeLecuyerGaussianRsg(LecuyerUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeLecuyerGaussianRsg\n"
		""},
	 { "InvCumulativeLecuyerGaussianRsg_nextSequence", _wrap_InvCumulativeLecuyerGaussianRsg_nextSequence, METH_O, "InvCumulativeLecuyerGaussianRsg_nextSequence(InvCumulativeLecuyerGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeLecuyerGaussianRsg_dimension", _wrap_InvCumulativeLecuyerGaussianRsg_dimension, METH_O, "InvCumulativeLecuyerGaussianRsg_dimension(InvCumulativeLecuyerGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeLecuyerGaussianRsg", _wrap_delete_InvCumulativeLecuyerGaussianRsg, METH_O, "delete_InvCumulativeLecuyerGaussianRsg(InvCumulativeLecuyerGaussianRsg self)"},
	 { "InvCumulativeLecuyerGaussianRsg_swigregister", InvCumulativeLecuyerGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeLecuyerGaussianRsg_swiginit", InvCumulativeLecuyerGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeKnuthGaussianRsg", _wrap_new_InvCumulativeKnuthGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeKnuthGaussianRsg(KnuthUniformRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeKnuthGaussianRsg(KnuthUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeKnuthGaussianRsg\n"
		""},
	 { "InvCumulativeKnuthGaussianRsg_nextSequence", _wrap_InvCumulativeKnuthGaussianRsg_nextSequence, METH_O, "InvCumulativeKnuthGaussianRsg_nextSequence(InvCumulativeKnuthGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeKnuthGaussianRsg_dimension", _wrap_InvCumulativeKnuthGaussianRsg_dimension, METH_O, "InvCumulativeKnuthGaussianRsg_dimension(InvCumulativeKnuthGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeKnuthGaussianRsg", _wrap_delete_InvCumulativeKnuthGaussianRsg, METH_O, "delete_InvCumulativeKnuthGaussianRsg(InvCumulativeKnuthGaussianRsg self)"},
	 { "InvCumulativeKnuthGaussianRsg_swigregister", InvCumulativeKnuthGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeKnuthGaussianRsg_swiginit", InvCumulativeKnuthGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeMersenneTwisterGaussianRsg", _wrap_new_InvCumulativeMersenneTwisterGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeMersenneTwisterGaussianRsg(MersenneTwisterUniformRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeMersenneTwisterGaussianRsg(MersenneTwisterUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeMersenneTwisterGaussianRsg\n"
		""},
	 { "InvCumulativeMersenneTwisterGaussianRsg_nextSequence", _wrap_InvCumulativeMersenneTwisterGaussianRsg_nextSequence, METH_O, "InvCumulativeMersenneTwisterGaussianRsg_nextSequence(InvCumulativeMersenneTwisterGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeMersenneTwisterGaussianRsg_dimension", _wrap_InvCumulativeMersenneTwisterGaussianRsg_dimension, METH_O, "InvCumulativeMersenneTwisterGaussianRsg_dimension(InvCumulativeMersenneTwisterGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeMersenneTwisterGaussianRsg", _wrap_delete_InvCumulativeMersenneTwisterGaussianRsg, METH_O, "delete_InvCumulativeMersenneTwisterGaussianRsg(InvCumulativeMersenneTwisterGaussianRsg self)"},
	 { "InvCumulativeMersenneTwisterGaussianRsg_swigregister", InvCumulativeMersenneTwisterGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterGaussianRsg_swiginit", InvCumulativeMersenneTwisterGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeXoshiro256StarStarGaussianRsg", _wrap_new_InvCumulativeXoshiro256StarStarGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeXoshiro256StarStarGaussianRsg(Xoshiro256StarStarUniformRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeXoshiro256StarStarGaussianRsg(Xoshiro256StarStarUniformRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeXoshiro256StarStarGaussianRsg\n"
		""},
	 { "InvCumulativeXoshiro256StarStarGaussianRsg_nextSequence", _wrap_InvCumulativeXoshiro256StarStarGaussianRsg_nextSequence, METH_O, "InvCumulativeXoshiro256StarStarGaussianRsg_nextSequence(InvCumulativeXoshiro256StarStarGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeXoshiro256StarStarGaussianRsg_dimension", _wrap_InvCumulativeXoshiro256StarStarGaussianRsg_dimension, METH_O, "InvCumulativeXoshiro256StarStarGaussianRsg_dimension(InvCumulativeXoshiro256StarStarGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeXoshiro256StarStarGaussianRsg", _wrap_delete_InvCumulativeXoshiro256StarStarGaussianRsg, METH_O, "delete_InvCumulativeXoshiro256StarStarGaussianRsg(InvCumulativeXoshiro256StarStarGaussianRsg self)"},
	 { "InvCumulativeXoshiro256StarStarGaussianRsg_swigregister", InvCumulativeXoshiro256StarStarGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeXoshiro256StarStarGaussianRsg_swiginit", InvCumulativeXoshiro256StarStarGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeHaltonGaussianRsg", _wrap_new_InvCumulativeHaltonGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeHaltonGaussianRsg(HaltonRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeHaltonGaussianRsg(HaltonRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeHaltonGaussianRsg\n"
		""},
	 { "InvCumulativeHaltonGaussianRsg_nextSequence", _wrap_InvCumulativeHaltonGaussianRsg_nextSequence, METH_O, "InvCumulativeHaltonGaussianRsg_nextSequence(InvCumulativeHaltonGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeHaltonGaussianRsg_dimension", _wrap_InvCumulativeHaltonGaussianRsg_dimension, METH_O, "InvCumulativeHaltonGaussianRsg_dimension(InvCumulativeHaltonGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeHaltonGaussianRsg", _wrap_delete_InvCumulativeHaltonGaussianRsg, METH_O, "delete_InvCumulativeHaltonGaussianRsg(InvCumulativeHaltonGaussianRsg self)"},
	 { "InvCumulativeHaltonGaussianRsg_swigregister", InvCumulativeHaltonGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeHaltonGaussianRsg_swiginit", InvCumulativeHaltonGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeSobolGaussianRsg", _wrap_new_InvCumulativeSobolGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeSobolGaussianRsg(SobolRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeSobolGaussianRsg(SobolRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeSobolGaussianRsg\n"
		""},
	 { "InvCumulativeSobolGaussianRsg_nextSequence", _wrap_InvCumulativeSobolGaussianRsg_nextSequence, METH_O, "InvCumulativeSobolGaussianRsg_nextSequence(InvCumulativeSobolGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeSobolGaussianRsg_dimension", _wrap_InvCumulativeSobolGaussianRsg_dimension, METH_O, "InvCumulativeSobolGaussianRsg_dimension(InvCumulativeSobolGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeSobolGaussianRsg", _wrap_delete_InvCumulativeSobolGaussianRsg, METH_O, "delete_InvCumulativeSobolGaussianRsg(InvCumulativeSobolGaussianRsg self)"},
	 { "InvCumulativeSobolGaussianRsg_swigregister", InvCumulativeSobolGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeSobolGaussianRsg_swiginit", InvCumulativeSobolGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeBurley2020SobolGaussianRsg", _wrap_new_InvCumulativeBurley2020SobolGaussianRsg, METH_VARARGS, "\n"
		"InvCumulativeBurley2020SobolGaussianRsg(Burley2020SobolRsg uniformSequenceGenerator)\n"
		"new_InvCumulativeBurley2020SobolGaussianRsg(Burley2020SobolRsg uniformSequenceGenerator, InverseCumulativeNormal inverseCumulative) -> InvCumulativeBurley2020SobolGaussianRsg\n"
		""},
	 { "InvCumulativeBurley2020SobolGaussianRsg_nextSequence", _wrap_InvCumulativeBurley2020SobolGaussianRsg_nextSequence, METH_O, "InvCumulativeBurley2020SobolGaussianRsg_nextSequence(InvCumulativeBurley2020SobolGaussianRsg self) -> SampleRealVector"},
	 { "InvCumulativeBurley2020SobolGaussianRsg_dimension", _wrap_InvCumulativeBurley2020SobolGaussianRsg_dimension, METH_O, "InvCumulativeBurley2020SobolGaussianRsg_dimension(InvCumulativeBurley2020SobolGaussianRsg self) -> Size"},
	 { "delete_InvCumulativeBurley2020SobolGaussianRsg", _wrap_delete_InvCumulativeBurley2020SobolGaussianRsg, METH_O, "delete_InvCumulativeBurley2020SobolGaussianRsg(InvCumulativeBurley2020SobolGaussianRsg self)"},
	 { "InvCumulativeBurley2020SobolGaussianRsg_swigregister", InvCumulativeBurley2020SobolGaussianRsg_swigregister, METH_O, NULL},
	 { "InvCumulativeBurley2020SobolGaussianRsg_swiginit", InvCumulativeBurley2020SobolGaussianRsg_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianRandomSequenceGenerator", _wrap_new_GaussianRandomSequenceGenerator, METH_O, "new_GaussianRandomSequenceGenerator(UniformRandomSequenceGenerator uniformSequenceGenerator) -> GaussianRandomSequenceGenerator"},
	 { "GaussianRandomSequenceGenerator_nextSequence", _wrap_GaussianRandomSequenceGenerator_nextSequence, METH_O, "GaussianRandomSequenceGenerator_nextSequence(GaussianRandomSequenceGenerator self) -> SampleRealVector"},
	 { "GaussianRandomSequenceGenerator_dimension", _wrap_GaussianRandomSequenceGenerator_dimension, METH_O, "GaussianRandomSequenceGenerator_dimension(GaussianRandomSequenceGenerator self) -> Size"},
	 { "delete_GaussianRandomSequenceGenerator", _wrap_delete_GaussianRandomSequenceGenerator, METH_O, "delete_GaussianRandomSequenceGenerator(GaussianRandomSequenceGenerator self)"},
	 { "GaussianRandomSequenceGenerator_swigregister", GaussianRandomSequenceGenerator_swigregister, METH_O, NULL},
	 { "GaussianRandomSequenceGenerator_swiginit", GaussianRandomSequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianLowDiscrepancySequenceGenerator", _wrap_new_GaussianLowDiscrepancySequenceGenerator, METH_O, "new_GaussianLowDiscrepancySequenceGenerator(UniformLowDiscrepancySequenceGenerator u) -> GaussianLowDiscrepancySequenceGenerator"},
	 { "GaussianLowDiscrepancySequenceGenerator_nextSequence", _wrap_GaussianLowDiscrepancySequenceGenerator_nextSequence, METH_O, "GaussianLowDiscrepancySequenceGenerator_nextSequence(GaussianLowDiscrepancySequenceGenerator self) -> SampleRealVector"},
	 { "GaussianLowDiscrepancySequenceGenerator_dimension", _wrap_GaussianLowDiscrepancySequenceGenerator_dimension, METH_O, "GaussianLowDiscrepancySequenceGenerator_dimension(GaussianLowDiscrepancySequenceGenerator self) -> Size"},
	 { "delete_GaussianLowDiscrepancySequenceGenerator", _wrap_delete_GaussianLowDiscrepancySequenceGenerator, METH_O, "delete_GaussianLowDiscrepancySequenceGenerator(GaussianLowDiscrepancySequenceGenerator self)"},
	 { "GaussianLowDiscrepancySequenceGenerator_swigregister", GaussianLowDiscrepancySequenceGenerator_swigregister, METH_O, NULL},
	 { "GaussianLowDiscrepancySequenceGenerator_swiginit", GaussianLowDiscrepancySequenceGenerator_swiginit, METH_VARARGS, NULL},
	 { "BrownianGenerator_nextStep", _wrap_BrownianGenerator_nextStep, METH_VARARGS, "BrownianGenerator_nextStep(BrownianGenerator self, DoubleVector arg2) -> Real"},
	 { "BrownianGenerator_nextPath", _wrap_BrownianGenerator_nextPath, METH_O, "BrownianGenerator_nextPath(BrownianGenerator self) -> Real"},
	 { "BrownianGenerator_numberOfFactors", _wrap_BrownianGenerator_numberOfFactors, METH_O, "BrownianGenerator_numberOfFactors(BrownianGenerator self) -> Size"},
	 { "BrownianGenerator_numberOfSteps", _wrap_BrownianGenerator_numberOfSteps, METH_O, "BrownianGenerator_numberOfSteps(BrownianGenerator self) -> Size"},
	 { "delete_BrownianGenerator", _wrap_delete_BrownianGenerator, METH_O, "delete_BrownianGenerator(BrownianGenerator self)"},
	 { "BrownianGenerator_swigregister", BrownianGenerator_swigregister, METH_O, NULL},
	 { "BrownianGeneratorFactory_create", _wrap_BrownianGeneratorFactory_create, METH_VARARGS, "BrownianGeneratorFactory_create(BrownianGeneratorFactory self, Size factors, Size steps) -> ext::shared_ptr< BrownianGenerator >"},
	 { "delete_BrownianGeneratorFactory", _wrap_delete_BrownianGeneratorFactory, METH_O, "delete_BrownianGeneratorFactory(BrownianGeneratorFactory self)"},
	 { "BrownianGeneratorFactory_swigregister", BrownianGeneratorFactory_swigregister, METH_O, NULL},
	 { "new_MTBrownianGenerator", _wrap_new_MTBrownianGenerator, METH_VARARGS, "MTBrownianGenerator(Size factors, Size steps, unsigned long seed=0)"},
	 { "delete_MTBrownianGenerator", _wrap_delete_MTBrownianGenerator, METH_O, "delete_MTBrownianGenerator(MTBrownianGenerator self)"},
	 { "MTBrownianGenerator_swigregister", MTBrownianGenerator_swigregister, METH_O, NULL},
	 { "MTBrownianGenerator_swiginit", MTBrownianGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_MTBrownianGeneratorFactory", _wrap_new_MTBrownianGeneratorFactory, METH_VARARGS, "MTBrownianGeneratorFactory(unsigned long seed=0)"},
	 { "delete_MTBrownianGeneratorFactory", _wrap_delete_MTBrownianGeneratorFactory, METH_O, "delete_MTBrownianGeneratorFactory(MTBrownianGeneratorFactory self)"},
	 { "MTBrownianGeneratorFactory_swigregister", MTBrownianGeneratorFactory_swigregister, METH_O, NULL},
	 { "MTBrownianGeneratorFactory_swiginit", MTBrownianGeneratorFactory_swiginit, METH_VARARGS, NULL},
	 { "new_SobolBrownianGenerator", _wrap_new_SobolBrownianGenerator, METH_VARARGS, "SobolBrownianGenerator(Size factors, Size steps, SobolBrownianGenerator::Ordering ordering, unsigned long seed=0, SobolRsg::DirectionIntegers directionIntegers=Jaeckel)"},
	 { "delete_SobolBrownianGenerator", _wrap_delete_SobolBrownianGenerator, METH_O, "delete_SobolBrownianGenerator(SobolBrownianGenerator self)"},
	 { "SobolBrownianGenerator_swigregister", SobolBrownianGenerator_swigregister, METH_O, NULL},
	 { "SobolBrownianGenerator_swiginit", SobolBrownianGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_SobolBrownianGeneratorFactory", _wrap_new_SobolBrownianGeneratorFactory, METH_VARARGS, "SobolBrownianGeneratorFactory(SobolBrownianGenerator::Ordering ordering, unsigned long seed=0, SobolRsg::DirectionIntegers directionIntegers=Jaeckel)"},
	 { "delete_SobolBrownianGeneratorFactory", _wrap_delete_SobolBrownianGeneratorFactory, METH_O, "delete_SobolBrownianGeneratorFactory(SobolBrownianGeneratorFactory self)"},
	 { "SobolBrownianGeneratorFactory_swigregister", SobolBrownianGeneratorFactory_swigregister, METH_O, NULL},
	 { "SobolBrownianGeneratorFactory_swiginit", SobolBrownianGeneratorFactory_swiginit, METH_VARARGS, NULL},
	 { "new_EvolutionDescription", _wrap_new_EvolutionDescription, METH_VARARGS, "EvolutionDescription(DoubleVector rateTimes, DoubleVector evolutionTimes={}, UnsignedIntPairVector relevanceRates={})"},
	 { "EvolutionDescription_rateTimes", _wrap_EvolutionDescription_rateTimes, METH_O, "EvolutionDescription_rateTimes(EvolutionDescription self) -> DoubleVector"},
	 { "EvolutionDescription_rateTaus", _wrap_EvolutionDescription_rateTaus, METH_O, "EvolutionDescription_rateTaus(EvolutionDescription self) -> DoubleVector"},
	 { "EvolutionDescription_evolutionTimes", _wrap_EvolutionDescription_evolutionTimes, METH_O, "EvolutionDescription_evolutionTimes(EvolutionDescription self) -> DoubleVector"},
	 { "EvolutionDescription_firstAliveRate", _wrap_EvolutionDescription_firstAliveRate, METH_O, "EvolutionDescription_firstAliveRate(EvolutionDescription self) -> UnsignedIntVector"},
	 { "EvolutionDescription_relevanceRates", _wrap_EvolutionDescription_relevanceRates, METH_O, "EvolutionDescription_relevanceRates(EvolutionDescription self) -> UnsignedIntPairVector"},
	 { "EvolutionDescription_numberOfRates", _wrap_EvolutionDescription_numberOfRates, METH_O, "EvolutionDescription_numberOfRates(EvolutionDescription self) -> Size"},
	 { "EvolutionDescription_numberOfSteps", _wrap_EvolutionDescription_numberOfSteps, METH_O, "EvolutionDescription_numberOfSteps(EvolutionDescription self) -> Size"},
	 { "delete_EvolutionDescription", _wrap_delete_EvolutionDescription, METH_O, "delete_EvolutionDescription(EvolutionDescription self)"},
	 { "EvolutionDescription_swigregister", EvolutionDescription_swigregister, METH_O, NULL},
	 { "EvolutionDescription_swiginit", EvolutionDescription_swiginit, METH_VARARGS, NULL},
	 { "checkCompatibility", _wrap_checkCompatibility, METH_VARARGS, "checkCompatibility(EvolutionDescription evolution, UnsignedIntVector numeraires)"},
	 { "isInTerminalMeasure", _wrap_isInTerminalMeasure, METH_VARARGS, "isInTerminalMeasure(EvolutionDescription evolution, UnsignedIntVector numeraires) -> bool"},
	 { "isInMoneyMarketPlusMeasure", _wrap_isInMoneyMarketPlusMeasure, METH_VARARGS, "isInMoneyMarketPlusMeasure(EvolutionDescription evolution, UnsignedIntVector numeraires, Size offset=1) -> bool"},
	 { "isInMoneyMarketMeasure", _wrap_isInMoneyMarketMeasure, METH_VARARGS, "isInMoneyMarketMeasure(EvolutionDescription evolution, UnsignedIntVector numeraires) -> bool"},
	 { "terminalMeasure", _wrap_terminalMeasure, METH_O, "terminalMeasure(EvolutionDescription evolution) -> UnsignedIntVector"},
	 { "moneyMarketPlusMeasure", _wrap_moneyMarketPlusMeasure, METH_VARARGS, "moneyMarketPlusMeasure(EvolutionDescription evolution, Size offset=1) -> UnsignedIntVector"},
	 { "moneyMarketMeasure", _wrap_moneyMarketMeasure, METH_O, "moneyMarketMeasure(EvolutionDescription evolution) -> UnsignedIntVector"},
	 { "MarketModel_initialRates", _wrap_MarketModel_initialRates, METH_O, "MarketModel_initialRates(MarketModel self) -> DoubleVector"},
	 { "MarketModel_displacements", _wrap_MarketModel_displacements, METH_O, "MarketModel_displacements(MarketModel self) -> DoubleVector"},
	 { "MarketModel_evolution", _wrap_MarketModel_evolution, METH_O, "MarketModel_evolution(MarketModel self) -> EvolutionDescription"},
	 { "MarketModel_numberOfRates", _wrap_MarketModel_numberOfRates, METH_O, "MarketModel_numberOfRates(MarketModel self) -> Size"},
	 { "MarketModel_numberOfFactors", _wrap_MarketModel_numberOfFactors, METH_O, "MarketModel_numberOfFactors(MarketModel self) -> Size"},
	 { "MarketModel_numberOfSteps", _wrap_MarketModel_numberOfSteps, METH_O, "MarketModel_numberOfSteps(MarketModel self) -> Size"},
	 { "MarketModel_pseudoRoot", _wrap_MarketModel_pseudoRoot, METH_VARARGS, "MarketModel_pseudoRoot(MarketModel self, Size i) -> Matrix"},
	 { "MarketModel_covariance", _wrap_MarketModel_covariance, METH_VARARGS, "MarketModel_covariance(MarketModel self, Size i) -> Matrix"},
	 { "MarketModel_totalCovariance", _wrap_MarketModel_totalCovariance, METH_VARARGS, "MarketModel_totalCovariance(MarketModel self, Size endIndex) -> Matrix"},
	 { "MarketModel_timeDependentVolatility", _wrap_MarketModel_timeDependentVolatility, METH_VARARGS, "MarketModel_timeDependentVolatility(MarketModel self, Size i) -> DoubleVector"},
	 { "delete_MarketModel", _wrap_delete_MarketModel, METH_O, "delete_MarketModel(MarketModel self)"},
	 { "MarketModel_swigregister", MarketModel_swigregister, METH_O, NULL},
	 { "MarketModelFactory_create", _wrap_MarketModelFactory_create, METH_VARARGS, "MarketModelFactory_create(MarketModelFactory self, EvolutionDescription arg2, Size numberOfFactors) -> ext::shared_ptr< MarketModel >"},
	 { "delete_MarketModelFactory", _wrap_delete_MarketModelFactory, METH_O, "delete_MarketModelFactory(MarketModelFactory self)"},
	 { "MarketModelFactory_swigregister", MarketModelFactory_swigregister, METH_O, NULL},
	 { "PiecewiseConstantCorrelation_times", _wrap_PiecewiseConstantCorrelation_times, METH_O, "PiecewiseConstantCorrelation_times(PiecewiseConstantCorrelation self) -> DoubleVector"},
	 { "PiecewiseConstantCorrelation_rateTimes", _wrap_PiecewiseConstantCorrelation_rateTimes, METH_O, "PiecewiseConstantCorrelation_rateTimes(PiecewiseConstantCorrelation self) -> DoubleVector"},
	 { "PiecewiseConstantCorrelation_correlations", _wrap_PiecewiseConstantCorrelation_correlations, METH_O, "PiecewiseConstantCorrelation_correlations(PiecewiseConstantCorrelation self) -> std::vector< Matrix,std::allocator< Matrix > > const &"},
	 { "PiecewiseConstantCorrelation_correlation", _wrap_PiecewiseConstantCorrelation_correlation, METH_VARARGS, "PiecewiseConstantCorrelation_correlation(PiecewiseConstantCorrelation self, Size i) -> Matrix"},
	 { "PiecewiseConstantCorrelation_numberOfRates", _wrap_PiecewiseConstantCorrelation_numberOfRates, METH_O, "PiecewiseConstantCorrelation_numberOfRates(PiecewiseConstantCorrelation self) -> Size"},
	 { "delete_PiecewiseConstantCorrelation", _wrap_delete_PiecewiseConstantCorrelation, METH_O, "delete_PiecewiseConstantCorrelation(PiecewiseConstantCorrelation self)"},
	 { "PiecewiseConstantCorrelation_swigregister", PiecewiseConstantCorrelation_swigregister, METH_O, NULL},
	 { "new_ExponentialForwardCorrelation", _wrap_new_ExponentialForwardCorrelation, METH_VARARGS, "ExponentialForwardCorrelation(DoubleVector rateTimes, Real longTermCorr=0.5, Real beta=0.2, Real gamma=1.0, DoubleVector times={})"},
	 { "delete_ExponentialForwardCorrelation", _wrap_delete_ExponentialForwardCorrelation, METH_O, "delete_ExponentialForwardCorrelation(ExponentialForwardCorrelation self)"},
	 { "ExponentialForwardCorrelation_swigregister", ExponentialForwardCorrelation_swigregister, METH_O, NULL},
	 { "ExponentialForwardCorrelation_swiginit", ExponentialForwardCorrelation_swiginit, METH_VARARGS, NULL},
	 { "CurveState_numberOfRates", _wrap_CurveState_numberOfRates, METH_O, "CurveState_numberOfRates(CurveState self) -> Size"},
	 { "CurveState_rateTimes", _wrap_CurveState_rateTimes, METH_O, "CurveState_rateTimes(CurveState self) -> DoubleVector"},
	 { "CurveState_rateTaus", _wrap_CurveState_rateTaus, METH_O, "CurveState_rateTaus(CurveState self) -> DoubleVector"},
	 { "CurveState_discountRatio", _wrap_CurveState_discountRatio, METH_VARARGS, "CurveState_discountRatio(CurveState self, Size i, Size j) -> Real"},
	 { "CurveState_forwardRate", _wrap_CurveState_forwardRate, METH_VARARGS, "CurveState_forwardRate(CurveState self, Size i) -> Rate"},
	 { "CurveState_coterminalSwapAnnuity", _wrap_CurveState_coterminalSwapAnnuity, METH_VARARGS, "CurveState_coterminalSwapAnnuity(CurveState self, Size numeraire, Size i) -> Rate"},
	 { "CurveState_coterminalSwapRate", _wrap_CurveState_coterminalSwapRate, METH_VARARGS, "CurveState_coterminalSwapRate(CurveState self, Size i) -> Rate"},
	 { "CurveState_cmSwapAnnuity", _wrap_CurveState_cmSwapAnnuity, METH_VARARGS, "CurveState_cmSwapAnnuity(CurveState self, Size numeraire, Size i, Size spanningForwards) -> Rate"},
	 { "CurveState_cmSwapRate", _wrap_CurveState_cmSwapRate, METH_VARARGS, "CurveState_cmSwapRate(CurveState self, Size i, Size spanningForwards) -> Rate"},
	 { "CurveState_forwardRates", _wrap_CurveState_forwardRates, METH_O, "CurveState_forwardRates(CurveState self) -> DoubleVector"},
	 { "CurveState_coterminalSwapRates", _wrap_CurveState_coterminalSwapRates, METH_O, "CurveState_coterminalSwapRates(CurveState self) -> DoubleVector"},
	 { "CurveState_cmSwapRates", _wrap_CurveState_cmSwapRates, METH_VARARGS, "CurveState_cmSwapRates(CurveState self, Size spanningForwards) -> DoubleVector"},
	 { "CurveState_swapRate", _wrap_CurveState_swapRate, METH_VARARGS, "CurveState_swapRate(CurveState self, Size begin, Size end) -> Rate"},
	 { "delete_CurveState", _wrap_delete_CurveState, METH_O, "delete_CurveState(CurveState self)"},
	 { "CurveState_swigregister", CurveState_swigregister, METH_O, NULL},
	 { "new_LMMCurveState", _wrap_new_LMMCurveState, METH_O, "new_LMMCurveState(DoubleVector rateTimes) -> LMMCurveState"},
	 { "LMMCurveState_setOnForwardRates", _wrap_LMMCurveState_setOnForwardRates, METH_VARARGS, "LMMCurveState_setOnForwardRates(LMMCurveState self, DoubleVector fwdRates, Size firstValidIndex=0)"},
	 { "LMMCurveState_setOnDiscountRatios", _wrap_LMMCurveState_setOnDiscountRatios, METH_VARARGS, "LMMCurveState_setOnDiscountRatios(LMMCurveState self, DoubleVector discRatios, Size firstValidIndex=0)"},
	 { "delete_LMMCurveState", _wrap_delete_LMMCurveState, METH_O, "delete_LMMCurveState(LMMCurveState self)"},
	 { "LMMCurveState_swigregister", LMMCurveState_swigregister, METH_O, NULL},
	 { "LMMCurveState_swiginit", LMMCurveState_swiginit, METH_VARARGS, NULL},
	 { "new_LMMDriftCalculator", _wrap_new_LMMDriftCalculator, METH_VARARGS, "new_LMMDriftCalculator(Matrix pseudo, DoubleVector displacements, DoubleVector taus, Size numeraire, Size alive) -> LMMDriftCalculator"},
	 { "LMMDriftCalculator_compute", _wrap_LMMDriftCalculator_compute, METH_VARARGS, "\n"
		"LMMDriftCalculator_compute(LMMDriftCalculator self, LMMCurveState cs, DoubleVector drifts)\n"
		"LMMDriftCalculator_compute(LMMDriftCalculator self, DoubleVector fwds, DoubleVector drifts)\n"
		""},
	 { "LMMDriftCalculator_computePlain", _wrap_LMMDriftCalculator_computePlain, METH_VARARGS, "\n"
		"LMMDriftCalculator_computePlain(LMMDriftCalculator self, LMMCurveState cs, DoubleVector drifts)\n"
		"LMMDriftCalculator_computePlain(LMMDriftCalculator self, DoubleVector fwds, DoubleVector drifts)\n"
		""},
	 { "LMMDriftCalculator_computeReduced", _wrap_LMMDriftCalculator_computeReduced, METH_VARARGS, "\n"
		"LMMDriftCalculator_computeReduced(LMMDriftCalculator self, LMMCurveState cs, DoubleVector drifts)\n"
		"LMMDriftCalculator_computeReduced(LMMDriftCalculator self, DoubleVector fwds, DoubleVector drifts)\n"
		""},
	 { "delete_LMMDriftCalculator", _wrap_delete_LMMDriftCalculator, METH_O, "delete_LMMDriftCalculator(LMMDriftCalculator self)"},
	 { "LMMDriftCalculator_swigregister", LMMDriftCalculator_swigregister, METH_O, NULL},
	 { "LMMDriftCalculator_swiginit", LMMDriftCalculator_swiginit, METH_VARARGS, NULL},
	 { "MarketModelEvolver_numeraires", _wrap_MarketModelEvolver_numeraires, METH_O, "MarketModelEvolver_numeraires(MarketModelEvolver self) -> UnsignedIntVector"},
	 { "MarketModelEvolver_startNewPath", _wrap_MarketModelEvolver_startNewPath, METH_O, "MarketModelEvolver_startNewPath(MarketModelEvolver self) -> Real"},
	 { "MarketModelEvolver_advanceStep", _wrap_MarketModelEvolver_advanceStep, METH_O, "MarketModelEvolver_advanceStep(MarketModelEvolver self) -> Real"},
	 { "MarketModelEvolver_currentStep", _wrap_MarketModelEvolver_currentStep, METH_O, "MarketModelEvolver_currentStep(MarketModelEvolver self) -> Size"},
	 { "MarketModelEvolver_currentState", _wrap_MarketModelEvolver_currentState, METH_O, "MarketModelEvolver_currentState(MarketModelEvolver self) -> CurveState"},
	 { "MarketModelEvolver_setInitialState", _wrap_MarketModelEvolver_setInitialState, METH_VARARGS, "MarketModelEvolver_setInitialState(MarketModelEvolver self, CurveState arg2)"},
	 { "delete_MarketModelEvolver", _wrap_delete_MarketModelEvolver, METH_O, "delete_MarketModelEvolver(MarketModelEvolver self)"},
	 { "MarketModelEvolver_swigregister", MarketModelEvolver_swigregister, METH_O, NULL},
	 { "new_LogNormalFwdRateIpc", _wrap_new_LogNormalFwdRateIpc, METH_VARARGS, "LogNormalFwdRateIpc(ext::shared_ptr< MarketModel > const & model, BrownianGeneratorFactory factory, UnsignedIntVector numeraires, Size initialStep=0)"},
	 { "delete_LogNormalFwdRateIpc", _wrap_delete_LogNormalFwdRateIpc, METH_O, "delete_LogNormalFwdRateIpc(LogNormalFwdRateIpc self)"},
	 { "LogNormalFwdRateIpc_swigregister", LogNormalFwdRateIpc_swigregister, METH_O, NULL},
	 { "LogNormalFwdRateIpc_swiginit", LogNormalFwdRateIpc_swiginit, METH_VARARGS, NULL},
	 { "new_AbcdVol", _wrap_new_AbcdVol, METH_VARARGS, "new_AbcdVol(Real a, Real b, Real c, Real d, DoubleVector ks, ext::shared_ptr< PiecewiseConstantCorrelation > const & corr, EvolutionDescription evolution, Size numberOfFactors, DoubleVector initialRates, DoubleVector displacements) -> AbcdVol"},
	 { "delete_AbcdVol", _wrap_delete_AbcdVol, METH_O, "delete_AbcdVol(AbcdVol self)"},
	 { "AbcdVol_swigregister", AbcdVol_swigregister, METH_O, NULL},
	 { "AbcdVol_swiginit", AbcdVol_swiginit, METH_VARARGS, NULL},
	 { "new_AbcdMathFunction", _wrap_new_AbcdMathFunction, METH_VARARGS, "\n"
		"AbcdMathFunction(Real a=0.002, Real b=0.001, Real c=0.16, Real d=0.0005)\n"
		"new_AbcdMathFunction(DoubleVector abcd) -> AbcdMathFunction\n"
		""},
	 { "AbcdMathFunction___call__", _wrap_AbcdMathFunction___call__, METH_VARARGS, "AbcdMathFunction___call__(AbcdMathFunction self, Time t) -> Real"},
	 { "AbcdMathFunction_maximumLocation", _wrap_AbcdMathFunction_maximumLocation, METH_O, "AbcdMathFunction_maximumLocation(AbcdMathFunction self) -> Time"},
	 { "AbcdMathFunction_maximumValue", _wrap_AbcdMathFunction_maximumValue, METH_O, "AbcdMathFunction_maximumValue(AbcdMathFunction self) -> Real"},
	 { "AbcdMathFunction_longTermValue", _wrap_AbcdMathFunction_longTermValue, METH_O, "AbcdMathFunction_longTermValue(AbcdMathFunction self) -> Real"},
	 { "AbcdMathFunction_derivative", _wrap_AbcdMathFunction_derivative, METH_VARARGS, "AbcdMathFunction_derivative(AbcdMathFunction self, Time t) -> Real"},
	 { "AbcdMathFunction_primitive", _wrap_AbcdMathFunction_primitive, METH_VARARGS, "AbcdMathFunction_primitive(AbcdMathFunction self, Time t) -> Real"},
	 { "AbcdMathFunction_definiteIntegral", _wrap_AbcdMathFunction_definiteIntegral, METH_VARARGS, "AbcdMathFunction_definiteIntegral(AbcdMathFunction self, Time t1, Time t2) -> Real"},
	 { "AbcdMathFunction_a", _wrap_AbcdMathFunction_a, METH_O, "AbcdMathFunction_a(AbcdMathFunction self) -> Real"},
	 { "AbcdMathFunction_b", _wrap_AbcdMathFunction_b, METH_O, "AbcdMathFunction_b(AbcdMathFunction self) -> Real"},
	 { "AbcdMathFunction_c", _wrap_AbcdMathFunction_c, METH_O, "AbcdMathFunction_c(AbcdMathFunction self) -> Real"},
	 { "AbcdMathFunction_d", _wrap_AbcdMathFunction_d, METH_O, "AbcdMathFunction_d(AbcdMathFunction self) -> Real"},
	 { "AbcdMathFunction_coefficients", _wrap_AbcdMathFunction_coefficients, METH_O, "AbcdMathFunction_coefficients(AbcdMathFunction self) -> DoubleVector"},
	 { "AbcdMathFunction_derivativeCoefficients", _wrap_AbcdMathFunction_derivativeCoefficients, METH_O, "AbcdMathFunction_derivativeCoefficients(AbcdMathFunction self) -> DoubleVector"},
	 { "AbcdMathFunction_definiteIntegralCoefficients", _wrap_AbcdMathFunction_definiteIntegralCoefficients, METH_VARARGS, "AbcdMathFunction_definiteIntegralCoefficients(AbcdMathFunction self, Time t, Time t2) -> DoubleVector"},
	 { "AbcdMathFunction_definiteDerivativeCoefficients", _wrap_AbcdMathFunction_definiteDerivativeCoefficients, METH_VARARGS, "AbcdMathFunction_definiteDerivativeCoefficients(AbcdMathFunction self, Time t, Time t2) -> DoubleVector"},
	 { "AbcdMathFunction_validate", _wrap_AbcdMathFunction_validate, METH_VARARGS, "AbcdMathFunction_validate(Real a, Real b, Real c, Real d)"},
	 { "delete_AbcdMathFunction", _wrap_delete_AbcdMathFunction, METH_O, "delete_AbcdMathFunction(AbcdMathFunction self)"},
	 { "AbcdMathFunction_swigregister", AbcdMathFunction_swigregister, METH_O, NULL},
	 { "AbcdMathFunction_swiginit", AbcdMathFunction_swiginit, METH_VARARGS, NULL},
	 { "new_AbcdFunction", _wrap_new_AbcdFunction, METH_VARARGS, "AbcdFunction(Real a=-0.06, Real b=0.17, Real c=0.54, Real d=0.17)"},
	 { "AbcdFunction_maximumVolatility", _wrap_AbcdFunction_maximumVolatility, METH_O, "AbcdFunction_maximumVolatility(AbcdFunction self) -> Real"},
	 { "AbcdFunction_shortTermVolatility", _wrap_AbcdFunction_shortTermVolatility, METH_O, "AbcdFunction_shortTermVolatility(AbcdFunction self) -> Real"},
	 { "AbcdFunction_longTermVolatility", _wrap_AbcdFunction_longTermVolatility, METH_O, "AbcdFunction_longTermVolatility(AbcdFunction self) -> Real"},
	 { "AbcdFunction_covariance", _wrap_AbcdFunction_covariance, METH_VARARGS, "\n"
		"AbcdFunction_covariance(AbcdFunction self, Time t, Time T, Time S) -> Real\n"
		"AbcdFunction_covariance(AbcdFunction self, Time t1, Time t2, Time T, Time S) -> Real\n"
		""},
	 { "AbcdFunction_volatility", _wrap_AbcdFunction_volatility, METH_VARARGS, "AbcdFunction_volatility(AbcdFunction self, Time tMin, Time tMax, Time T) -> Real"},
	 { "AbcdFunction_variance", _wrap_AbcdFunction_variance, METH_VARARGS, "AbcdFunction_variance(AbcdFunction self, Time tMin, Time tMax, Time T) -> Real"},
	 { "AbcdFunction_instantaneousVolatility", _wrap_AbcdFunction_instantaneousVolatility, METH_VARARGS, "AbcdFunction_instantaneousVolatility(AbcdFunction self, Time t, Time T) -> Real"},
	 { "AbcdFunction_instantaneousVariance", _wrap_AbcdFunction_instantaneousVariance, METH_VARARGS, "AbcdFunction_instantaneousVariance(AbcdFunction self, Time t, Time T) -> Real"},
	 { "AbcdFunction_instantaneousCovariance", _wrap_AbcdFunction_instantaneousCovariance, METH_VARARGS, "AbcdFunction_instantaneousCovariance(AbcdFunction self, Time u, Time T, Time S) -> Real"},
	 { "AbcdFunction_primitive", _wrap_AbcdFunction_primitive, METH_VARARGS, "AbcdFunction_primitive(AbcdFunction self, Time t, Time T, Time S) -> Real"},
	 { "delete_AbcdFunction", _wrap_delete_AbcdFunction, METH_O, "delete_AbcdFunction(AbcdFunction self)"},
	 { "AbcdFunction_swigregister", AbcdFunction_swigregister, METH_O, NULL},
	 { "AbcdFunction_swiginit", AbcdFunction_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousFloatingLookbackOption", _wrap_new_ContinuousFloatingLookbackOption, METH_VARARGS, "new_ContinuousFloatingLookbackOption(Real currentMinmax, ext::shared_ptr< TypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousFloatingLookbackOption"},
	 { "delete_ContinuousFloatingLookbackOption", _wrap_delete_ContinuousFloatingLookbackOption, METH_O, "delete_ContinuousFloatingLookbackOption(ContinuousFloatingLookbackOption self)"},
	 { "ContinuousFloatingLookbackOption_swigregister", ContinuousFloatingLookbackOption_swigregister, METH_O, NULL},
	 { "ContinuousFloatingLookbackOption_swiginit", ContinuousFloatingLookbackOption_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousFixedLookbackOption", _wrap_new_ContinuousFixedLookbackOption, METH_VARARGS, "new_ContinuousFixedLookbackOption(Real currentMinmax, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousFixedLookbackOption"},
	 { "delete_ContinuousFixedLookbackOption", _wrap_delete_ContinuousFixedLookbackOption, METH_O, "delete_ContinuousFixedLookbackOption(ContinuousFixedLookbackOption self)"},
	 { "ContinuousFixedLookbackOption_swigregister", ContinuousFixedLookbackOption_swigregister, METH_O, NULL},
	 { "ContinuousFixedLookbackOption_swiginit", ContinuousFixedLookbackOption_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousPartialFloatingLookbackOption", _wrap_new_ContinuousPartialFloatingLookbackOption, METH_VARARGS, "new_ContinuousPartialFloatingLookbackOption(Real currentMinmax, Real lambda_parameter, Date lookbackPeriodEnd, ext::shared_ptr< TypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousPartialFloatingLookbackOption"},
	 { "delete_ContinuousPartialFloatingLookbackOption", _wrap_delete_ContinuousPartialFloatingLookbackOption, METH_O, "delete_ContinuousPartialFloatingLookbackOption(ContinuousPartialFloatingLookbackOption self)"},
	 { "ContinuousPartialFloatingLookbackOption_swigregister", ContinuousPartialFloatingLookbackOption_swigregister, METH_O, NULL},
	 { "ContinuousPartialFloatingLookbackOption_swiginit", ContinuousPartialFloatingLookbackOption_swiginit, METH_VARARGS, NULL},
	 { "new_ContinuousPartialFixedLookbackOption", _wrap_new_ContinuousPartialFixedLookbackOption, METH_VARARGS, "new_ContinuousPartialFixedLookbackOption(Date lookbackPeriodStart, ext::shared_ptr< StrikedTypePayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> ContinuousPartialFixedLookbackOption"},
	 { "delete_ContinuousPartialFixedLookbackOption", _wrap_delete_ContinuousPartialFixedLookbackOption, METH_O, "delete_ContinuousPartialFixedLookbackOption(ContinuousPartialFixedLookbackOption self)"},
	 { "ContinuousPartialFixedLookbackOption_swigregister", ContinuousPartialFixedLookbackOption_swigregister, METH_O, NULL},
	 { "ContinuousPartialFixedLookbackOption_swiginit", ContinuousPartialFixedLookbackOption_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousFloatingLookbackEngine", _wrap_new_AnalyticContinuousFloatingLookbackEngine, METH_O, "new_AnalyticContinuousFloatingLookbackEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousFloatingLookbackEngine"},
	 { "delete_AnalyticContinuousFloatingLookbackEngine", _wrap_delete_AnalyticContinuousFloatingLookbackEngine, METH_O, "delete_AnalyticContinuousFloatingLookbackEngine(AnalyticContinuousFloatingLookbackEngine self)"},
	 { "AnalyticContinuousFloatingLookbackEngine_swigregister", AnalyticContinuousFloatingLookbackEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousFloatingLookbackEngine_swiginit", AnalyticContinuousFloatingLookbackEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousFixedLookbackEngine", _wrap_new_AnalyticContinuousFixedLookbackEngine, METH_O, "new_AnalyticContinuousFixedLookbackEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousFixedLookbackEngine"},
	 { "delete_AnalyticContinuousFixedLookbackEngine", _wrap_delete_AnalyticContinuousFixedLookbackEngine, METH_O, "delete_AnalyticContinuousFixedLookbackEngine(AnalyticContinuousFixedLookbackEngine self)"},
	 { "AnalyticContinuousFixedLookbackEngine_swigregister", AnalyticContinuousFixedLookbackEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousFixedLookbackEngine_swiginit", AnalyticContinuousFixedLookbackEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousPartialFloatingLookbackEngine", _wrap_new_AnalyticContinuousPartialFloatingLookbackEngine, METH_O, "new_AnalyticContinuousPartialFloatingLookbackEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousPartialFloatingLookbackEngine"},
	 { "delete_AnalyticContinuousPartialFloatingLookbackEngine", _wrap_delete_AnalyticContinuousPartialFloatingLookbackEngine, METH_O, "delete_AnalyticContinuousPartialFloatingLookbackEngine(AnalyticContinuousPartialFloatingLookbackEngine self)"},
	 { "AnalyticContinuousPartialFloatingLookbackEngine_swigregister", AnalyticContinuousPartialFloatingLookbackEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousPartialFloatingLookbackEngine_swiginit", AnalyticContinuousPartialFloatingLookbackEngine_swiginit, METH_VARARGS, NULL},
	 { "new_AnalyticContinuousPartialFixedLookbackEngine", _wrap_new_AnalyticContinuousPartialFixedLookbackEngine, METH_O, "new_AnalyticContinuousPartialFixedLookbackEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process) -> AnalyticContinuousPartialFixedLookbackEngine"},
	 { "delete_AnalyticContinuousPartialFixedLookbackEngine", _wrap_delete_AnalyticContinuousPartialFixedLookbackEngine, METH_O, "delete_AnalyticContinuousPartialFixedLookbackEngine(AnalyticContinuousPartialFixedLookbackEngine self)"},
	 { "AnalyticContinuousPartialFixedLookbackEngine_swigregister", AnalyticContinuousPartialFixedLookbackEngine_swigregister, METH_O, NULL},
	 { "AnalyticContinuousPartialFixedLookbackEngine_swiginit", AnalyticContinuousPartialFixedLookbackEngine_swiginit, METH_VARARGS, NULL},
	 { "getCovariance", _wrap_getCovariance, METH_VARARGS, "getCovariance(Array volatilities, Matrix correlations) -> Matrix"},
	 { "Path___len__", _wrap_Path___len__, METH_O, "Path___len__(Path self) -> Size"},
	 { "Path_value", _wrap_Path_value, METH_VARARGS, "Path_value(Path self, Size i) -> Real"},
	 { "Path_front", _wrap_Path_front, METH_O, "Path_front(Path self) -> Real"},
	 { "Path_back", _wrap_Path_back, METH_O, "Path_back(Path self) -> Real"},
	 { "Path_time", _wrap_Path_time, METH_VARARGS, "Path_time(Path self, Size i) -> Time"},
	 { "Path___getitem__", _wrap_Path___getitem__, METH_VARARGS, "Path___getitem__(Path self, Integer i) -> Real"},
	 { "delete_Path", _wrap_delete_Path, METH_O, "delete_Path(Path self)"},
	 { "Path_swigregister", Path_swigregister, METH_O, NULL},
	 { "SamplePath_value", _wrap_SamplePath_value, METH_O, "SamplePath_value(SamplePath self) -> Path"},
	 { "SamplePath_weight", _wrap_SamplePath_weight, METH_O, "SamplePath_weight(SamplePath self) -> Real"},
	 { "delete_SamplePath", _wrap_delete_SamplePath, METH_O, "delete_SamplePath(SamplePath self)"},
	 { "SamplePath_swigregister", SamplePath_swigregister, METH_O, NULL},
	 { "new_GaussianPathGenerator", _wrap_new_GaussianPathGenerator, METH_VARARGS, "\n"
		"GaussianPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, Time length, Size timeSteps, GaussianRandomSequenceGenerator generator, bool brownianBridge)\n"
		"new_GaussianPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, TimeGrid timeGrid, GaussianRandomSequenceGenerator generator, bool brownianBridge) -> GaussianPathGenerator\n"
		""},
	 { "GaussianPathGenerator_next", _wrap_GaussianPathGenerator_next, METH_O, "GaussianPathGenerator_next(GaussianPathGenerator self) -> SamplePath"},
	 { "GaussianPathGenerator_antithetic", _wrap_GaussianPathGenerator_antithetic, METH_O, "GaussianPathGenerator_antithetic(GaussianPathGenerator self) -> SamplePath"},
	 { "GaussianPathGenerator_size", _wrap_GaussianPathGenerator_size, METH_O, "GaussianPathGenerator_size(GaussianPathGenerator self) -> Size"},
	 { "GaussianPathGenerator_timeGrid", _wrap_GaussianPathGenerator_timeGrid, METH_O, "GaussianPathGenerator_timeGrid(GaussianPathGenerator self) -> TimeGrid"},
	 { "delete_GaussianPathGenerator", _wrap_delete_GaussianPathGenerator, METH_O, "delete_GaussianPathGenerator(GaussianPathGenerator self)"},
	 { "GaussianPathGenerator_swigregister", GaussianPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianPathGenerator_swiginit", GaussianPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianSobolPathGenerator", _wrap_new_GaussianSobolPathGenerator, METH_VARARGS, "\n"
		"GaussianSobolPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, Time length, Size timeSteps, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge)\n"
		"new_GaussianSobolPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, TimeGrid timeGrid, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge) -> GaussianSobolPathGenerator\n"
		""},
	 { "GaussianSobolPathGenerator_next", _wrap_GaussianSobolPathGenerator_next, METH_O, "GaussianSobolPathGenerator_next(GaussianSobolPathGenerator self) -> SamplePath"},
	 { "GaussianSobolPathGenerator_antithetic", _wrap_GaussianSobolPathGenerator_antithetic, METH_O, "GaussianSobolPathGenerator_antithetic(GaussianSobolPathGenerator self) -> SamplePath"},
	 { "GaussianSobolPathGenerator_size", _wrap_GaussianSobolPathGenerator_size, METH_O, "GaussianSobolPathGenerator_size(GaussianSobolPathGenerator self) -> Size"},
	 { "GaussianSobolPathGenerator_timeGrid", _wrap_GaussianSobolPathGenerator_timeGrid, METH_O, "GaussianSobolPathGenerator_timeGrid(GaussianSobolPathGenerator self) -> TimeGrid"},
	 { "delete_GaussianSobolPathGenerator", _wrap_delete_GaussianSobolPathGenerator, METH_O, "delete_GaussianSobolPathGenerator(GaussianSobolPathGenerator self)"},
	 { "GaussianSobolPathGenerator_swigregister", GaussianSobolPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianSobolPathGenerator_swiginit", GaussianSobolPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_InvCumulativeMersenneTwisterPathGenerator", _wrap_new_InvCumulativeMersenneTwisterPathGenerator, METH_VARARGS, "\n"
		"InvCumulativeMersenneTwisterPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, Time length, Size timeSteps, InvCumulativeMersenneTwisterGaussianRsg generator, bool brownianBridge)\n"
		"new_InvCumulativeMersenneTwisterPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, TimeGrid timeGrid, InvCumulativeMersenneTwisterGaussianRsg generator, bool brownianBridge) -> InvCumulativeMersenneTwisterPathGenerator\n"
		""},
	 { "InvCumulativeMersenneTwisterPathGenerator_next", _wrap_InvCumulativeMersenneTwisterPathGenerator_next, METH_O, "InvCumulativeMersenneTwisterPathGenerator_next(InvCumulativeMersenneTwisterPathGenerator self) -> SamplePath"},
	 { "InvCumulativeMersenneTwisterPathGenerator_antithetic", _wrap_InvCumulativeMersenneTwisterPathGenerator_antithetic, METH_O, "InvCumulativeMersenneTwisterPathGenerator_antithetic(InvCumulativeMersenneTwisterPathGenerator self) -> SamplePath"},
	 { "InvCumulativeMersenneTwisterPathGenerator_size", _wrap_InvCumulativeMersenneTwisterPathGenerator_size, METH_O, "InvCumulativeMersenneTwisterPathGenerator_size(InvCumulativeMersenneTwisterPathGenerator self) -> Size"},
	 { "InvCumulativeMersenneTwisterPathGenerator_timeGrid", _wrap_InvCumulativeMersenneTwisterPathGenerator_timeGrid, METH_O, "InvCumulativeMersenneTwisterPathGenerator_timeGrid(InvCumulativeMersenneTwisterPathGenerator self) -> TimeGrid"},
	 { "delete_InvCumulativeMersenneTwisterPathGenerator", _wrap_delete_InvCumulativeMersenneTwisterPathGenerator, METH_O, "delete_InvCumulativeMersenneTwisterPathGenerator(InvCumulativeMersenneTwisterPathGenerator self)"},
	 { "InvCumulativeMersenneTwisterPathGenerator_swigregister", InvCumulativeMersenneTwisterPathGenerator_swigregister, METH_O, NULL},
	 { "InvCumulativeMersenneTwisterPathGenerator_swiginit", InvCumulativeMersenneTwisterPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "MultiPath___len__", _wrap_MultiPath___len__, METH_O, "MultiPath___len__(MultiPath self) -> Size"},
	 { "MultiPath_assetNumber", _wrap_MultiPath_assetNumber, METH_O, "MultiPath_assetNumber(MultiPath self) -> Size"},
	 { "MultiPath_at", _wrap_MultiPath_at, METH_VARARGS, "MultiPath_at(MultiPath self, Size j) -> Path"},
	 { "MultiPath___getitem__", _wrap_MultiPath___getitem__, METH_VARARGS, "MultiPath___getitem__(MultiPath self, Integer i) -> Path"},
	 { "delete_MultiPath", _wrap_delete_MultiPath, METH_O, "delete_MultiPath(MultiPath self)"},
	 { "MultiPath_swigregister", MultiPath_swigregister, METH_O, NULL},
	 { "SampleMultiPath_value", _wrap_SampleMultiPath_value, METH_O, "SampleMultiPath_value(SampleMultiPath self) -> MultiPath"},
	 { "SampleMultiPath_weight", _wrap_SampleMultiPath_weight, METH_O, "SampleMultiPath_weight(SampleMultiPath self) -> Real"},
	 { "delete_SampleMultiPath", _wrap_delete_SampleMultiPath, METH_O, "delete_SampleMultiPath(SampleMultiPath self)"},
	 { "SampleMultiPath_swigregister", SampleMultiPath_swigregister, METH_O, NULL},
	 { "new_GaussianMultiPathGenerator", _wrap_new_GaussianMultiPathGenerator, METH_VARARGS, "\n"
		"GaussianMultiPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, TimeGrid timeGrid, GaussianRandomSequenceGenerator generator, bool brownianBridge=False)\n"
		"GaussianMultiPathGenerator(ext::shared_ptr< StochasticProcess > const & process, DoubleVector times, GaussianRandomSequenceGenerator generator, bool brownianBridge=False)\n"
		""},
	 { "GaussianMultiPathGenerator_next", _wrap_GaussianMultiPathGenerator_next, METH_O, "GaussianMultiPathGenerator_next(GaussianMultiPathGenerator self) -> SampleMultiPath"},
	 { "GaussianMultiPathGenerator_antithetic", _wrap_GaussianMultiPathGenerator_antithetic, METH_O, "GaussianMultiPathGenerator_antithetic(GaussianMultiPathGenerator self) -> SampleMultiPath"},
	 { "delete_GaussianMultiPathGenerator", _wrap_delete_GaussianMultiPathGenerator, METH_O, "delete_GaussianMultiPathGenerator(GaussianMultiPathGenerator self)"},
	 { "GaussianMultiPathGenerator_swigregister", GaussianMultiPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianMultiPathGenerator_swiginit", GaussianMultiPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_GaussianSobolMultiPathGenerator", _wrap_new_GaussianSobolMultiPathGenerator, METH_VARARGS, "\n"
		"GaussianSobolMultiPathGenerator(ext::shared_ptr< StochasticProcess > const & arg1, TimeGrid timeGrid, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge=False)\n"
		"GaussianSobolMultiPathGenerator(ext::shared_ptr< StochasticProcess > const & process, DoubleVector times, GaussianLowDiscrepancySequenceGenerator generator, bool brownianBridge=False)\n"
		""},
	 { "GaussianSobolMultiPathGenerator_next", _wrap_GaussianSobolMultiPathGenerator_next, METH_O, "GaussianSobolMultiPathGenerator_next(GaussianSobolMultiPathGenerator self) -> SampleMultiPath"},
	 { "GaussianSobolMultiPathGenerator_antithetic", _wrap_GaussianSobolMultiPathGenerator_antithetic, METH_O, "GaussianSobolMultiPathGenerator_antithetic(GaussianSobolMultiPathGenerator self) -> SampleMultiPath"},
	 { "delete_GaussianSobolMultiPathGenerator", _wrap_delete_GaussianSobolMultiPathGenerator, METH_O, "delete_GaussianSobolMultiPathGenerator(GaussianSobolMultiPathGenerator self)"},
	 { "GaussianSobolMultiPathGenerator_swigregister", GaussianSobolMultiPathGenerator_swigregister, METH_O, NULL},
	 { "GaussianSobolMultiPathGenerator_swiginit", GaussianSobolMultiPathGenerator_swiginit, METH_VARARGS, NULL},
	 { "new_BrownianBridge", _wrap_new_BrownianBridge, METH_VARARGS, "\n"
		"BrownianBridge(Size steps)\n"
		"BrownianBridge(DoubleVector times)\n"
		"new_BrownianBridge(TimeGrid timeGrid) -> BrownianBridge\n"
		""},
	 { "BrownianBridge_size", _wrap_BrownianBridge_size, METH_O, "BrownianBridge_size(BrownianBridge self) -> Size"},
	 { "BrownianBridge_times", _wrap_BrownianBridge_times, METH_O, "BrownianBridge_times(BrownianBridge self) -> DoubleVector"},
	 { "BrownianBridge_leftWeight", _wrap_BrownianBridge_leftWeight, METH_O, "BrownianBridge_leftWeight(BrownianBridge self) -> DoubleVector"},
	 { "BrownianBridge_rightWeight", _wrap_BrownianBridge_rightWeight, METH_O, "BrownianBridge_rightWeight(BrownianBridge self) -> DoubleVector"},
	 { "BrownianBridge_stdDeviation", _wrap_BrownianBridge_stdDeviation, METH_O, "BrownianBridge_stdDeviation(BrownianBridge self) -> DoubleVector"},
	 { "BrownianBridge_transform", _wrap_BrownianBridge_transform, METH_VARARGS, "BrownianBridge_transform(BrownianBridge self, DoubleVector input) -> DoubleVector"},
	 { "BrownianBridge_bridgeIndex", _wrap_BrownianBridge_bridgeIndex, METH_O, "BrownianBridge_bridgeIndex(BrownianBridge self) -> UnsignedIntVector"},
	 { "BrownianBridge_leftIndex", _wrap_BrownianBridge_leftIndex, METH_O, "BrownianBridge_leftIndex(BrownianBridge self) -> UnsignedIntVector"},
	 { "BrownianBridge_rightIndex", _wrap_BrownianBridge_rightIndex, METH_O, "BrownianBridge_rightIndex(BrownianBridge self) -> UnsignedIntVector"},
	 { "delete_BrownianBridge", _wrap_delete_BrownianBridge, METH_O, "delete_BrownianBridge(BrownianBridge self)"},
	 { "BrownianBridge_swigregister", BrownianBridge_swigregister, METH_O, NULL},
	 { "BrownianBridge_swiginit", BrownianBridge_swiginit, METH_VARARGS, NULL},
	 { "new_RungeKutta", _wrap_new_RungeKutta, METH_VARARGS, "RungeKutta(Real const eps=1.0e-6, Real const h1=1.0e-4, Real const hmin=0.0)"},
	 { "RungeKutta___call__", _wrap_RungeKutta___call__, METH_VARARGS, "\n"
		"RungeKutta___call__(RungeKutta self, PyObject * fct, double y1, Real x1, Real x2) -> double\n"
		"RungeKutta___call__(RungeKutta self, PyObject * fct, DoubleVector y1, Real x1, Real x2) -> DoubleVector\n"
		""},
	 { "delete_RungeKutta", _wrap_delete_RungeKutta, METH_O, "delete_RungeKutta(RungeKutta self)"},
	 { "RungeKutta_swigregister", RungeKutta_swigregister, METH_O, NULL},
	 { "RungeKutta_swiginit", RungeKutta_swiginit, METH_VARARGS, NULL},
	 { "delete_DefaultBoundaryCondition", _wrap_delete_DefaultBoundaryCondition, METH_O, "delete_DefaultBoundaryCondition(DefaultBoundaryCondition self)"},
	 { "DefaultBoundaryCondition_swigregister", DefaultBoundaryCondition_swigregister, METH_O, NULL},
	 { "new_NeumannBC", _wrap_new_NeumannBC, METH_VARARGS, "new_NeumannBC(Real value, DefaultBoundaryCondition::Side side) -> NeumannBC"},
	 { "delete_NeumannBC", _wrap_delete_NeumannBC, METH_O, "delete_NeumannBC(NeumannBC self)"},
	 { "NeumannBC_swigregister", NeumannBC_swigregister, METH_O, NULL},
	 { "NeumannBC_swiginit", NeumannBC_swiginit, METH_VARARGS, NULL},
	 { "new_DirichletBC", _wrap_new_DirichletBC, METH_VARARGS, "new_DirichletBC(Real value, DefaultBoundaryCondition::Side side) -> DirichletBC"},
	 { "delete_DirichletBC", _wrap_delete_DirichletBC, METH_O, "delete_DirichletBC(DirichletBC self)"},
	 { "DirichletBC_swigregister", DirichletBC_swigregister, METH_O, NULL},
	 { "DirichletBC_swiginit", DirichletBC_swiginit, METH_VARARGS, NULL},
	 { "new_TridiagonalOperator", _wrap_new_TridiagonalOperator, METH_VARARGS, "new_TridiagonalOperator(Array low, Array mid, Array high) -> TridiagonalOperator"},
	 { "TridiagonalOperator_solveFor", _wrap_TridiagonalOperator_solveFor, METH_VARARGS, "TridiagonalOperator_solveFor(TridiagonalOperator self, Array rhs) -> Array"},
	 { "TridiagonalOperator_applyTo", _wrap_TridiagonalOperator_applyTo, METH_VARARGS, "TridiagonalOperator_applyTo(TridiagonalOperator self, Array v) -> Array"},
	 { "TridiagonalOperator_size", _wrap_TridiagonalOperator_size, METH_O, "TridiagonalOperator_size(TridiagonalOperator self) -> Size"},
	 { "TridiagonalOperator_setFirstRow", _wrap_TridiagonalOperator_setFirstRow, METH_VARARGS, "TridiagonalOperator_setFirstRow(TridiagonalOperator self, Real arg2, Real arg3)"},
	 { "TridiagonalOperator_setMidRow", _wrap_TridiagonalOperator_setMidRow, METH_VARARGS, "TridiagonalOperator_setMidRow(TridiagonalOperator self, Size arg2, Real arg3, Real arg4, Real arg5)"},
	 { "TridiagonalOperator_setMidRows", _wrap_TridiagonalOperator_setMidRows, METH_VARARGS, "TridiagonalOperator_setMidRows(TridiagonalOperator self, Real arg2, Real arg3, Real arg4)"},
	 { "TridiagonalOperator_setLastRow", _wrap_TridiagonalOperator_setLastRow, METH_VARARGS, "TridiagonalOperator_setLastRow(TridiagonalOperator self, Real arg2, Real arg3)"},
	 { "TridiagonalOperator_identity", _wrap_TridiagonalOperator_identity, METH_O, "TridiagonalOperator_identity(Size size) -> TridiagonalOperator"},
	 { "TridiagonalOperator___add__", _wrap_TridiagonalOperator___add__, METH_VARARGS, "TridiagonalOperator___add__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"},
	 { "TridiagonalOperator___sub__", _wrap_TridiagonalOperator___sub__, METH_VARARGS, "TridiagonalOperator___sub__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"},
	 { "TridiagonalOperator___mul__", _wrap_TridiagonalOperator___mul__, METH_VARARGS, "TridiagonalOperator___mul__(TridiagonalOperator self, Real a) -> TridiagonalOperator"},
	 { "TridiagonalOperator___div__", _wrap_TridiagonalOperator___div__, METH_VARARGS, "TridiagonalOperator___div__(TridiagonalOperator self, Real a) -> TridiagonalOperator"},
	 { "TridiagonalOperator___iadd__", _wrap_TridiagonalOperator___iadd__, METH_VARARGS, "TridiagonalOperator___iadd__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"},
	 { "TridiagonalOperator___isub__", _wrap_TridiagonalOperator___isub__, METH_VARARGS, "TridiagonalOperator___isub__(TridiagonalOperator self, TridiagonalOperator O) -> TridiagonalOperator"},
	 { "TridiagonalOperator___imul__", _wrap_TridiagonalOperator___imul__, METH_VARARGS, "TridiagonalOperator___imul__(TridiagonalOperator self, Real a) -> TridiagonalOperator"},
	 { "TridiagonalOperator___rmul__", _wrap_TridiagonalOperator___rmul__, METH_VARARGS, "TridiagonalOperator___rmul__(TridiagonalOperator self, Real a) -> TridiagonalOperator"},
	 { "TridiagonalOperator___idiv__", _wrap_TridiagonalOperator___idiv__, METH_VARARGS, "TridiagonalOperator___idiv__(TridiagonalOperator self, Real a) -> TridiagonalOperator"},
	 { "delete_TridiagonalOperator", _wrap_delete_TridiagonalOperator, METH_O, "delete_TridiagonalOperator(TridiagonalOperator self)"},
	 { "TridiagonalOperator_swigregister", TridiagonalOperator_swigregister, METH_O, NULL},
	 { "TridiagonalOperator_swiginit", TridiagonalOperator_swiginit, METH_VARARGS, NULL},
	 { "new_DPlus", _wrap_new_DPlus, METH_VARARGS, "new_DPlus(Size gridPoints, Real h) -> DPlus"},
	 { "delete_DPlus", _wrap_delete_DPlus, METH_O, "delete_DPlus(DPlus self)"},
	 { "DPlus_swigregister", DPlus_swigregister, METH_O, NULL},
	 { "DPlus_swiginit", DPlus_swiginit, METH_VARARGS, NULL},
	 { "new_DMinus", _wrap_new_DMinus, METH_VARARGS, "new_DMinus(Size gridPoints, Real h) -> DMinus"},
	 { "delete_DMinus", _wrap_delete_DMinus, METH_O, "delete_DMinus(DMinus self)"},
	 { "DMinus_swigregister", DMinus_swigregister, METH_O, NULL},
	 { "DMinus_swiginit", DMinus_swiginit, METH_VARARGS, NULL},
	 { "new_DZero", _wrap_new_DZero, METH_VARARGS, "new_DZero(Size gridPoints, Real h) -> DZero"},
	 { "delete_DZero", _wrap_delete_DZero, METH_O, "delete_DZero(DZero self)"},
	 { "DZero_swigregister", DZero_swigregister, METH_O, NULL},
	 { "DZero_swiginit", DZero_swiginit, METH_VARARGS, NULL},
	 { "new_DPlusDMinus", _wrap_new_DPlusDMinus, METH_VARARGS, "new_DPlusDMinus(Size gridPoints, Real h) -> DPlusDMinus"},
	 { "delete_DPlusDMinus", _wrap_delete_DPlusDMinus, METH_O, "delete_DPlusDMinus(DPlusDMinus self)"},
	 { "DPlusDMinus_swigregister", DPlusDMinus_swigregister, METH_O, NULL},
	 { "DPlusDMinus_swiginit", DPlusDMinus_swiginit, METH_VARARGS, NULL},
	 { "new_SampledCurve", _wrap_new_SampledCurve, METH_VARARGS, "\n"
		"SampledCurve()\n"
		"new_SampledCurve(Array arg1) -> SampledCurve\n"
		""},
	 { "SampledCurve_grid", _wrap_SampledCurve_grid, METH_O, "SampledCurve_grid(SampledCurve self) -> Array"},
	 { "SampledCurve_values", _wrap_SampledCurve_values, METH_O, "SampledCurve_values(SampledCurve self) -> Array"},
	 { "SampledCurve_gridValue", _wrap_SampledCurve_gridValue, METH_VARARGS, "SampledCurve_gridValue(SampledCurve self, Size i) -> Real"},
	 { "SampledCurve_value", _wrap_SampledCurve_value, METH_VARARGS, "SampledCurve_value(SampledCurve self, Size i) -> Real"},
	 { "SampledCurve_size", _wrap_SampledCurve_size, METH_O, "SampledCurve_size(SampledCurve self) -> Size"},
	 { "SampledCurve_empty", _wrap_SampledCurve_empty, METH_O, "SampledCurve_empty(SampledCurve self) -> bool"},
	 { "SampledCurve_setGrid", _wrap_SampledCurve_setGrid, METH_VARARGS, "SampledCurve_setGrid(SampledCurve self, Array arg2)"},
	 { "SampledCurve_setValues", _wrap_SampledCurve_setValues, METH_VARARGS, "SampledCurve_setValues(SampledCurve self, Array arg2)"},
	 { "SampledCurve_swap", _wrap_SampledCurve_swap, METH_VARARGS, "SampledCurve_swap(SampledCurve self, SampledCurve arg2)"},
	 { "SampledCurve_setLogGrid", _wrap_SampledCurve_setLogGrid, METH_VARARGS, "SampledCurve_setLogGrid(SampledCurve self, Real min, Real max)"},
	 { "SampledCurve_regridLogGrid", _wrap_SampledCurve_regridLogGrid, METH_VARARGS, "SampledCurve_regridLogGrid(SampledCurve self, Real min, Real max)"},
	 { "SampledCurve_shiftGrid", _wrap_SampledCurve_shiftGrid, METH_VARARGS, "SampledCurve_shiftGrid(SampledCurve self, Real s)"},
	 { "SampledCurve_scaleGrid", _wrap_SampledCurve_scaleGrid, METH_VARARGS, "SampledCurve_scaleGrid(SampledCurve self, Real s)"},
	 { "SampledCurve_regrid", _wrap_SampledCurve_regrid, METH_VARARGS, "SampledCurve_regrid(SampledCurve self, Array arg2)"},
	 { "delete_SampledCurve", _wrap_delete_SampledCurve, METH_O, "delete_SampledCurve(SampledCurve self)"},
	 { "SampledCurve_swigregister", SampledCurve_swigregister, METH_O, NULL},
	 { "SampledCurve_swiginit", SampledCurve_swiginit, METH_VARARGS, NULL},
	 { "new_HestonSLVProcess", _wrap_new_HestonSLVProcess, METH_VARARGS, "HestonSLVProcess(ext::shared_ptr< HestonProcess > const & hestonProcess, ext::shared_ptr< LocalVolTermStructure > const & leverageFct, Real const mixingFactor=1.0)"},
	 { "delete_HestonSLVProcess", _wrap_delete_HestonSLVProcess, METH_O, "delete_HestonSLVProcess(HestonSLVProcess self)"},
	 { "HestonSLVProcess_swigregister", HestonSLVProcess_swigregister, METH_O, NULL},
	 { "HestonSLVProcess_swiginit", HestonSLVProcess_swiginit, METH_VARARGS, NULL},
	 { "new_HestonSLVMCModel", _wrap_new_HestonSLVMCModel, METH_VARARGS, "HestonSLVMCModel(ext::shared_ptr< LocalVolTermStructure > const & localVol, ext::shared_ptr< HestonModel > const & model, ext::shared_ptr< BrownianGeneratorFactory > const & brownianGeneratorFactory, Date endDate, Size timeStepsPerYear=365, Size nBins=201, Size calibrationPaths=(1 << 15), DateVector mandatoryDates=std::vector< Date >(), Real mixingFactor=1.0)"},
	 { "HestonSLVMCModel_hestonProcess", _wrap_HestonSLVMCModel_hestonProcess, METH_O, "HestonSLVMCModel_hestonProcess(HestonSLVMCModel self) -> ext::shared_ptr< HestonProcess >"},
	 { "HestonSLVMCModel_localVol", _wrap_HestonSLVMCModel_localVol, METH_O, "HestonSLVMCModel_localVol(HestonSLVMCModel self) -> ext::shared_ptr< LocalVolTermStructure >"},
	 { "HestonSLVMCModel_leverageFunction", _wrap_HestonSLVMCModel_leverageFunction, METH_O, "HestonSLVMCModel_leverageFunction(HestonSLVMCModel self) -> ext::shared_ptr< LocalVolTermStructure >"},
	 { "delete_HestonSLVMCModel", _wrap_delete_HestonSLVMCModel, METH_O, "delete_HestonSLVMCModel(HestonSLVMCModel self)"},
	 { "HestonSLVMCModel_swigregister", HestonSLVMCModel_swigregister, METH_O, NULL},
	 { "HestonSLVMCModel_swiginit", HestonSLVMCModel_swiginit, METH_VARARGS, NULL},
	 { "delete_FdmHestonGreensFct", _wrap_delete_FdmHestonGreensFct, METH_O, "delete_FdmHestonGreensFct(FdmHestonGreensFct self)"},
	 { "FdmHestonGreensFct_swigregister", FdmHestonGreensFct_swigregister, METH_O, NULL},
	 { "new_HestonSLVFokkerPlanckFdmParams", _wrap_new_HestonSLVFokkerPlanckFdmParams, METH_VARARGS, "new_HestonSLVFokkerPlanckFdmParams(Size xGrid, Size vGrid, Size tMaxStepsPerYear, Size tMinStepsPerYear, Real tStepNumberDecay, Size nRannacherTimeSteps, Size predictionCorretionSteps, Real x0Density, Real localVolEpsProb, Size maxIntegrationIterations, Real vLowerEps, Real vUpperEps, Real vMin, Real v0Density, Real vLowerBoundDensity, Real vUpperBoundDensity, Real leverageFctPropEps, FdmHestonGreensFct::Algorithm greensAlgorithm, FdmSquareRootFwdOp::TransformationType trafoType, FdmSchemeDesc schemeDesc) -> HestonSLVFokkerPlanckFdmParams"},
	 { "delete_HestonSLVFokkerPlanckFdmParams", _wrap_delete_HestonSLVFokkerPlanckFdmParams, METH_O, "delete_HestonSLVFokkerPlanckFdmParams(HestonSLVFokkerPlanckFdmParams self)"},
	 { "HestonSLVFokkerPlanckFdmParams_swigregister", HestonSLVFokkerPlanckFdmParams_swigregister, METH_O, NULL},
	 { "HestonSLVFokkerPlanckFdmParams_swiginit", HestonSLVFokkerPlanckFdmParams_swiginit, METH_VARARGS, NULL},
	 { "new_HestonSLVFDMModel", _wrap_new_HestonSLVFDMModel, METH_VARARGS, "HestonSLVFDMModel(ext::shared_ptr< LocalVolTermStructure > const & localVol, ext::shared_ptr< HestonModel > const & model, Date endDate, HestonSLVFokkerPlanckFdmParams params, bool const logging=False, DateVector mandatoryDates=std::vector< Date >(), Real mixingFactor=1.0)"},
	 { "HestonSLVFDMModel_hestonProcess", _wrap_HestonSLVFDMModel_hestonProcess, METH_O, "HestonSLVFDMModel_hestonProcess(HestonSLVFDMModel self) -> ext::shared_ptr< HestonProcess >"},
	 { "HestonSLVFDMModel_localVol", _wrap_HestonSLVFDMModel_localVol, METH_O, "HestonSLVFDMModel_localVol(HestonSLVFDMModel self) -> ext::shared_ptr< LocalVolTermStructure >"},
	 { "HestonSLVFDMModel_leverageFunction", _wrap_HestonSLVFDMModel_leverageFunction, METH_O, "HestonSLVFDMModel_leverageFunction(HestonSLVFDMModel self) -> ext::shared_ptr< LocalVolTermStructure >"},
	 { "delete_HestonSLVFDMModel", _wrap_delete_HestonSLVFDMModel, METH_O, "delete_HestonSLVFDMModel(HestonSLVFDMModel self)"},
	 { "HestonSLVFDMModel_swigregister", HestonSLVFDMModel_swigregister, METH_O, NULL},
	 { "HestonSLVFDMModel_swiginit", HestonSLVFDMModel_swiginit, METH_VARARGS, NULL},
	 { "new_SpreadOption", _wrap_new_SpreadOption, METH_VARARGS, "new_SpreadOption(ext::shared_ptr< PlainVanillaPayoff > const & payoff, ext::shared_ptr< Exercise > const & exercise) -> SpreadOption"},
	 { "delete_SpreadOption", _wrap_delete_SpreadOption, METH_O, "delete_SpreadOption(SpreadOption self)"},
	 { "SpreadOption_swigregister", SpreadOption_swigregister, METH_O, NULL},
	 { "SpreadOption_swiginit", SpreadOption_swiginit, METH_VARARGS, NULL},
	 { "new_KirkSpreadOptionEngine", _wrap_new_KirkSpreadOptionEngine, METH_VARARGS, "new_KirkSpreadOptionEngine(ext::shared_ptr< BlackProcess > const & process1, ext::shared_ptr< BlackProcess > const & process2, QuoteHandle correlation) -> KirkSpreadOptionEngine"},
	 { "delete_KirkSpreadOptionEngine", _wrap_delete_KirkSpreadOptionEngine, METH_O, "delete_KirkSpreadOptionEngine(KirkSpreadOptionEngine self)"},
	 { "KirkSpreadOptionEngine_swigregister", KirkSpreadOptionEngine_swigregister, METH_O, NULL},
	 { "KirkSpreadOptionEngine_swiginit", KirkSpreadOptionEngine_swiginit, METH_VARARGS, NULL},
	 { "Statistics_samples", _wrap_Statistics_samples, METH_O, "Statistics_samples(Statistics self) -> Size"},
	 { "Statistics_weightSum", _wrap_Statistics_weightSum, METH_O, "Statistics_weightSum(Statistics self) -> Real"},
	 { "Statistics_mean", _wrap_Statistics_mean, METH_O, "Statistics_mean(Statistics self) -> Real"},
	 { "Statistics_variance", _wrap_Statistics_variance, METH_O, "Statistics_variance(Statistics self) -> Real"},
	 { "Statistics_standardDeviation", _wrap_Statistics_standardDeviation, METH_O, "Statistics_standardDeviation(Statistics self) -> Real"},
	 { "Statistics_errorEstimate", _wrap_Statistics_errorEstimate, METH_O, "Statistics_errorEstimate(Statistics self) -> Real"},
	 { "Statistics_skewness", _wrap_Statistics_skewness, METH_O, "Statistics_skewness(Statistics self) -> Real"},
	 { "Statistics_kurtosis", _wrap_Statistics_kurtosis, METH_O, "Statistics_kurtosis(Statistics self) -> Real"},
	 { "Statistics_min", _wrap_Statistics_min, METH_O, "Statistics_min(Statistics self) -> Real"},
	 { "Statistics_max", _wrap_Statistics_max, METH_O, "Statistics_max(Statistics self) -> Real"},
	 { "Statistics_reset", _wrap_Statistics_reset, METH_O, "Statistics_reset(Statistics self)"},
	 { "Statistics_add", _wrap_Statistics_add, METH_VARARGS, "\n"
		"Statistics_add(Statistics self, Real value, Real weight=1.0)\n"
		"Statistics_add(Statistics self, DoubleVector values)\n"
		"Statistics_add(Statistics self, DoubleVector values, DoubleVector weights)\n"
		""},
	 { "new_Statistics", _wrap_new_Statistics, METH_NOARGS, "new_Statistics() -> Statistics"},
	 { "delete_Statistics", _wrap_delete_Statistics, METH_O, "delete_Statistics(Statistics self)"},
	 { "Statistics_swigregister", Statistics_swigregister, METH_O, NULL},
	 { "Statistics_swiginit", Statistics_swiginit, METH_VARARGS, NULL},
	 { "IncrementalStatistics_samples", _wrap_IncrementalStatistics_samples, METH_O, "IncrementalStatistics_samples(IncrementalStatistics self) -> Size"},
	 { "IncrementalStatistics_weightSum", _wrap_IncrementalStatistics_weightSum, METH_O, "IncrementalStatistics_weightSum(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_mean", _wrap_IncrementalStatistics_mean, METH_O, "IncrementalStatistics_mean(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_variance", _wrap_IncrementalStatistics_variance, METH_O, "IncrementalStatistics_variance(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_standardDeviation", _wrap_IncrementalStatistics_standardDeviation, METH_O, "IncrementalStatistics_standardDeviation(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_errorEstimate", _wrap_IncrementalStatistics_errorEstimate, METH_O, "IncrementalStatistics_errorEstimate(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_skewness", _wrap_IncrementalStatistics_skewness, METH_O, "IncrementalStatistics_skewness(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_kurtosis", _wrap_IncrementalStatistics_kurtosis, METH_O, "IncrementalStatistics_kurtosis(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_min", _wrap_IncrementalStatistics_min, METH_O, "IncrementalStatistics_min(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_max", _wrap_IncrementalStatistics_max, METH_O, "IncrementalStatistics_max(IncrementalStatistics self) -> Real"},
	 { "IncrementalStatistics_reset", _wrap_IncrementalStatistics_reset, METH_O, "IncrementalStatistics_reset(IncrementalStatistics self)"},
	 { "IncrementalStatistics_add", _wrap_IncrementalStatistics_add, METH_VARARGS, "\n"
		"IncrementalStatistics_add(IncrementalStatistics self, Real value, Real weight=1.0)\n"
		"IncrementalStatistics_add(IncrementalStatistics self, DoubleVector values)\n"
		"IncrementalStatistics_add(IncrementalStatistics self, DoubleVector values, DoubleVector weights)\n"
		""},
	 { "new_IncrementalStatistics", _wrap_new_IncrementalStatistics, METH_NOARGS, "new_IncrementalStatistics() -> IncrementalStatistics"},
	 { "delete_IncrementalStatistics", _wrap_delete_IncrementalStatistics, METH_O, "delete_IncrementalStatistics(IncrementalStatistics self)"},
	 { "IncrementalStatistics_swigregister", IncrementalStatistics_swigregister, METH_O, NULL},
	 { "IncrementalStatistics_swiginit", IncrementalStatistics_swiginit, METH_VARARGS, NULL},
	 { "RiskStatistics_semiVariance", _wrap_RiskStatistics_semiVariance, METH_O, "RiskStatistics_semiVariance(RiskStatistics self) -> Real"},
	 { "RiskStatistics_semiDeviation", _wrap_RiskStatistics_semiDeviation, METH_O, "RiskStatistics_semiDeviation(RiskStatistics self) -> Real"},
	 { "RiskStatistics_downsideVariance", _wrap_RiskStatistics_downsideVariance, METH_O, "RiskStatistics_downsideVariance(RiskStatistics self) -> Real"},
	 { "RiskStatistics_downsideDeviation", _wrap_RiskStatistics_downsideDeviation, METH_O, "RiskStatistics_downsideDeviation(RiskStatistics self) -> Real"},
	 { "RiskStatistics_regret", _wrap_RiskStatistics_regret, METH_VARARGS, "RiskStatistics_regret(RiskStatistics self, Real target) -> Real"},
	 { "RiskStatistics_potentialUpside", _wrap_RiskStatistics_potentialUpside, METH_VARARGS, "RiskStatistics_potentialUpside(RiskStatistics self, Real percentile) -> Real"},
	 { "RiskStatistics_valueAtRisk", _wrap_RiskStatistics_valueAtRisk, METH_VARARGS, "RiskStatistics_valueAtRisk(RiskStatistics self, Real percentile) -> Real"},
	 { "RiskStatistics_expectedShortfall", _wrap_RiskStatistics_expectedShortfall, METH_VARARGS, "RiskStatistics_expectedShortfall(RiskStatistics self, Real percentile) -> Real"},
	 { "RiskStatistics_shortfall", _wrap_RiskStatistics_shortfall, METH_VARARGS, "RiskStatistics_shortfall(RiskStatistics self, Real target) -> Real"},
	 { "RiskStatistics_averageShortfall", _wrap_RiskStatistics_averageShortfall, METH_VARARGS, "RiskStatistics_averageShortfall(RiskStatistics self, Real target) -> Real"},
	 { "new_RiskStatistics", _wrap_new_RiskStatistics, METH_NOARGS, "new_RiskStatistics() -> RiskStatistics"},
	 { "delete_RiskStatistics", _wrap_delete_RiskStatistics, METH_O, "delete_RiskStatistics(RiskStatistics self)"},
	 { "RiskStatistics_swigregister", RiskStatistics_swigregister, METH_O, NULL},
	 { "RiskStatistics_swiginit", RiskStatistics_swiginit, METH_VARARGS, NULL},
	 { "new_MultipleStatistics", _wrap_new_MultipleStatistics, METH_O, "new_MultipleStatistics(Size dimension) -> MultipleStatistics"},
	 { "MultipleStatistics_size", _wrap_MultipleStatistics_size, METH_O, "MultipleStatistics_size(MultipleStatistics self) -> Size"},
	 { "MultipleStatistics_samples", _wrap_MultipleStatistics_samples, METH_O, "MultipleStatistics_samples(MultipleStatistics self) -> Size"},
	 { "MultipleStatistics_weightSum", _wrap_MultipleStatistics_weightSum, METH_O, "MultipleStatistics_weightSum(MultipleStatistics self) -> Real"},
	 { "MultipleStatistics_mean", _wrap_MultipleStatistics_mean, METH_O, "MultipleStatistics_mean(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_variance", _wrap_MultipleStatistics_variance, METH_O, "MultipleStatistics_variance(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_standardDeviation", _wrap_MultipleStatistics_standardDeviation, METH_O, "MultipleStatistics_standardDeviation(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_errorEstimate", _wrap_MultipleStatistics_errorEstimate, METH_O, "MultipleStatistics_errorEstimate(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_skewness", _wrap_MultipleStatistics_skewness, METH_O, "MultipleStatistics_skewness(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_kurtosis", _wrap_MultipleStatistics_kurtosis, METH_O, "MultipleStatistics_kurtosis(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_min", _wrap_MultipleStatistics_min, METH_O, "MultipleStatistics_min(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_max", _wrap_MultipleStatistics_max, METH_O, "MultipleStatistics_max(MultipleStatistics self) -> DoubleVector"},
	 { "MultipleStatistics_covariance", _wrap_MultipleStatistics_covariance, METH_O, "MultipleStatistics_covariance(MultipleStatistics self) -> Matrix"},
	 { "MultipleStatistics_correlation", _wrap_MultipleStatistics_correlation, METH_O, "MultipleStatistics_correlation(MultipleStatistics self) -> Matrix"},
	 { "MultipleStatistics_reset", _wrap_MultipleStatistics_reset, METH_O, "MultipleStatistics_reset(MultipleStatistics self)"},
	 { "MultipleStatistics_add", _wrap_MultipleStatistics_add, METH_VARARGS, "\n"
		"MultipleStatistics_add(MultipleStatistics self, DoubleVector value, Real weight=1.0)\n"
		"MultipleStatistics_add(MultipleStatistics self, Array value, Real weight=1.0)\n"
		""},
	 { "delete_MultipleStatistics", _wrap_delete_MultipleStatistics, METH_O, "delete_MultipleStatistics(MultipleStatistics self)"},
	 { "MultipleStatistics_swigregister", MultipleStatistics_swigregister, METH_O, NULL},
	 { "MultipleStatistics_swiginit", MultipleStatistics_swiginit, METH_VARARGS, NULL},
	 { "new_SequenceStatistics", _wrap_new_SequenceStatistics, METH_O, "new_SequenceStatistics(Size dimension) -> SequenceStatistics"},
	 { "SequenceStatistics_size", _wrap_SequenceStatistics_size, METH_O, "SequenceStatistics_size(SequenceStatistics self) -> Size"},
	 { "SequenceStatistics_samples", _wrap_SequenceStatistics_samples, METH_O, "SequenceStatistics_samples(SequenceStatistics self) -> Size"},
	 { "SequenceStatistics_weightSum", _wrap_SequenceStatistics_weightSum, METH_O, "SequenceStatistics_weightSum(SequenceStatistics self) -> Real"},
	 { "SequenceStatistics_mean", _wrap_SequenceStatistics_mean, METH_O, "SequenceStatistics_mean(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_variance", _wrap_SequenceStatistics_variance, METH_O, "SequenceStatistics_variance(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_standardDeviation", _wrap_SequenceStatistics_standardDeviation, METH_O, "SequenceStatistics_standardDeviation(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_errorEstimate", _wrap_SequenceStatistics_errorEstimate, METH_O, "SequenceStatistics_errorEstimate(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_skewness", _wrap_SequenceStatistics_skewness, METH_O, "SequenceStatistics_skewness(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_kurtosis", _wrap_SequenceStatistics_kurtosis, METH_O, "SequenceStatistics_kurtosis(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_min", _wrap_SequenceStatistics_min, METH_O, "SequenceStatistics_min(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_max", _wrap_SequenceStatistics_max, METH_O, "SequenceStatistics_max(SequenceStatistics self) -> DoubleVector"},
	 { "SequenceStatistics_covariance", _wrap_SequenceStatistics_covariance, METH_O, "SequenceStatistics_covariance(SequenceStatistics self) -> Matrix"},
	 { "SequenceStatistics_correlation", _wrap_SequenceStatistics_correlation, METH_O, "SequenceStatistics_correlation(SequenceStatistics self) -> Matrix"},
	 { "SequenceStatistics_reset", _wrap_SequenceStatistics_reset, METH_O, "SequenceStatistics_reset(SequenceStatistics self)"},
	 { "SequenceStatistics_add", _wrap_SequenceStatistics_add, METH_VARARGS, "\n"
		"SequenceStatistics_add(SequenceStatistics self, DoubleVector value, Real weight=1.0)\n"
		"SequenceStatistics_add(SequenceStatistics self, Array value, Real weight=1.0)\n"
		""},
	 { "delete_SequenceStatistics", _wrap_delete_SequenceStatistics, METH_O, "delete_SequenceStatistics(SequenceStatistics self)"},
	 { "SequenceStatistics_swigregister", SequenceStatistics_swigregister, METH_O, NULL},
	 { "SequenceStatistics_swiginit", SequenceStatistics_swiginit, METH_VARARGS, NULL},
	 { "new_MultipleIncrementalStatistics", _wrap_new_MultipleIncrementalStatistics, METH_O, "new_MultipleIncrementalStatistics(Size dimension) -> MultipleIncrementalStatistics"},
	 { "MultipleIncrementalStatistics_size", _wrap_MultipleIncrementalStatistics_size, METH_O, "MultipleIncrementalStatistics_size(MultipleIncrementalStatistics self) -> Size"},
	 { "MultipleIncrementalStatistics_samples", _wrap_MultipleIncrementalStatistics_samples, METH_O, "MultipleIncrementalStatistics_samples(MultipleIncrementalStatistics self) -> Size"},
	 { "MultipleIncrementalStatistics_weightSum", _wrap_MultipleIncrementalStatistics_weightSum, METH_O, "MultipleIncrementalStatistics_weightSum(MultipleIncrementalStatistics self) -> Real"},
	 { "MultipleIncrementalStatistics_mean", _wrap_MultipleIncrementalStatistics_mean, METH_O, "MultipleIncrementalStatistics_mean(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_variance", _wrap_MultipleIncrementalStatistics_variance, METH_O, "MultipleIncrementalStatistics_variance(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_standardDeviation", _wrap_MultipleIncrementalStatistics_standardDeviation, METH_O, "MultipleIncrementalStatistics_standardDeviation(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_errorEstimate", _wrap_MultipleIncrementalStatistics_errorEstimate, METH_O, "MultipleIncrementalStatistics_errorEstimate(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_skewness", _wrap_MultipleIncrementalStatistics_skewness, METH_O, "MultipleIncrementalStatistics_skewness(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_kurtosis", _wrap_MultipleIncrementalStatistics_kurtosis, METH_O, "MultipleIncrementalStatistics_kurtosis(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_min", _wrap_MultipleIncrementalStatistics_min, METH_O, "MultipleIncrementalStatistics_min(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_max", _wrap_MultipleIncrementalStatistics_max, METH_O, "MultipleIncrementalStatistics_max(MultipleIncrementalStatistics self) -> DoubleVector"},
	 { "MultipleIncrementalStatistics_covariance", _wrap_MultipleIncrementalStatistics_covariance, METH_O, "MultipleIncrementalStatistics_covariance(MultipleIncrementalStatistics self) -> Matrix"},
	 { "MultipleIncrementalStatistics_correlation", _wrap_MultipleIncrementalStatistics_correlation, METH_O, "MultipleIncrementalStatistics_correlation(MultipleIncrementalStatistics self) -> Matrix"},
	 { "MultipleIncrementalStatistics_reset", _wrap_MultipleIncrementalStatistics_reset, METH_O, "MultipleIncrementalStatistics_reset(MultipleIncrementalStatistics self)"},
	 { "MultipleIncrementalStatistics_add", _wrap_MultipleIncrementalStatistics_add, METH_VARARGS, "\n"
		"MultipleIncrementalStatistics_add(MultipleIncrementalStatistics self, DoubleVector value, Real weight=1.0)\n"
		"MultipleIncrementalStatistics_add(MultipleIncrementalStatistics self, Array value, Real weight=1.0)\n"
		""},
	 { "delete_MultipleIncrementalStatistics", _wrap_delete_MultipleIncrementalStatistics, METH_O, "delete_MultipleIncrementalStatistics(MultipleIncrementalStatistics self)"},
	 { "MultipleIncrementalStatistics_swigregister", MultipleIncrementalStatistics_swigregister, METH_O, NULL},
	 { "MultipleIncrementalStatistics_swiginit", MultipleIncrementalStatistics_swiginit, METH_VARARGS, NULL},
	 { "CapFloorTermVolatilityStructure_volatility", _wrap_CapFloorTermVolatilityStructure_volatility, METH_VARARGS, "\n"
		"CapFloorTermVolatilityStructure_volatility(CapFloorTermVolatilityStructure self, Period length, Rate strike, bool extrapolate=False) -> Volatility\n"
		"CapFloorTermVolatilityStructure_volatility(CapFloorTermVolatilityStructure self, Date end, Rate strike, bool extrapolate=False) -> Volatility\n"
		"CapFloorTermVolatilityStructure_volatility(CapFloorTermVolatilityStructure self, Time end, Rate strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "delete_CapFloorTermVolatilityStructure", _wrap_delete_CapFloorTermVolatilityStructure, METH_O, "delete_CapFloorTermVolatilityStructure(CapFloorTermVolatilityStructure self)"},
	 { "CapFloorTermVolatilityStructure_swigregister", CapFloorTermVolatilityStructure_swigregister, METH_O, NULL},
	 { "new_CapFloorTermVolatilityStructureHandle", _wrap_new_CapFloorTermVolatilityStructureHandle, METH_VARARGS, "CapFloorTermVolatilityStructureHandle(ext::shared_ptr< CapFloorTermVolatilityStructure > const & arg1=ext::shared_ptr())"},
	 { "CapFloorTermVolatilityStructureHandle___deref__", _wrap_CapFloorTermVolatilityStructureHandle___deref__, METH_O, "CapFloorTermVolatilityStructureHandle___deref__(CapFloorTermVolatilityStructureHandle self) -> ext::shared_ptr< CapFloorTermVolatilityStructure >"},
	 { "CapFloorTermVolatilityStructureHandle_currentLink", _wrap_CapFloorTermVolatilityStructureHandle_currentLink, METH_O, "CapFloorTermVolatilityStructureHandle_currentLink(CapFloorTermVolatilityStructureHandle self) -> ext::shared_ptr< CapFloorTermVolatilityStructure >"},
	 { "CapFloorTermVolatilityStructureHandle___nonzero__", _wrap_CapFloorTermVolatilityStructureHandle___nonzero__, METH_O, "CapFloorTermVolatilityStructureHandle___nonzero__(CapFloorTermVolatilityStructureHandle self) -> bool"},
	 { "CapFloorTermVolatilityStructureHandle___bool__", _wrap_CapFloorTermVolatilityStructureHandle___bool__, METH_O, "CapFloorTermVolatilityStructureHandle___bool__(CapFloorTermVolatilityStructureHandle self) -> bool"},
	 { "CapFloorTermVolatilityStructureHandle_asObservable", _wrap_CapFloorTermVolatilityStructureHandle_asObservable, METH_O, "CapFloorTermVolatilityStructureHandle_asObservable(CapFloorTermVolatilityStructureHandle self) -> ext::shared_ptr< Observable >"},
	 { "delete_CapFloorTermVolatilityStructureHandle", _wrap_delete_CapFloorTermVolatilityStructureHandle, METH_O, "delete_CapFloorTermVolatilityStructureHandle(CapFloorTermVolatilityStructureHandle self)"},
	 { "CapFloorTermVolatilityStructureHandle_volatility", _wrap_CapFloorTermVolatilityStructureHandle_volatility, METH_VARARGS, "\n"
		"CapFloorTermVolatilityStructureHandle_volatility(CapFloorTermVolatilityStructureHandle self, Period length, Rate strike, bool extrapolate=False) -> Volatility\n"
		"CapFloorTermVolatilityStructureHandle_volatility(CapFloorTermVolatilityStructureHandle self, Date end, Rate strike, bool extrapolate=False) -> Volatility\n"
		"CapFloorTermVolatilityStructureHandle_volatility(CapFloorTermVolatilityStructureHandle self, Time end, Rate strike, bool extrapolate=False) -> Volatility\n"
		""},
	 { "CapFloorTermVolatilityStructureHandle_minStrike", _wrap_CapFloorTermVolatilityStructureHandle_minStrike, METH_O, "CapFloorTermVolatilityStructureHandle_minStrike(CapFloorTermVolatilityStructureHandle self) -> Real"},
	 { "CapFloorTermVolatilityStructureHandle_maxStrike", _wrap_CapFloorTermVolatilityStructureHandle_maxStrike, METH_O, "CapFloorTermVolatilityStructureHandle_maxStrike(CapFloorTermVolatilityStructureHandle self) -> Real"},
	 { "CapFloorTermVolatilityStructureHandle_dayCounter", _wrap_CapFloorTermVolatilityStructureHandle_dayCounter, METH_O, "CapFloorTermVolatilityStructureHandle_dayCounter(CapFloorTermVolatilityStructureHandle self) -> DayCounter"},
	 { "CapFloorTermVolatilityStructureHandle_timeFromReference", _wrap_CapFloorTermVolatilityStructureHandle_timeFromReference, METH_VARARGS, "CapFloorTermVolatilityStructureHandle_timeFromReference(CapFloorTermVolatilityStructureHandle self, Date date) -> Time"},
	 { "CapFloorTermVolatilityStructureHandle_calendar", _wrap_CapFloorTermVolatilityStructureHandle_calendar, METH_O, "CapFloorTermVolatilityStructureHandle_calendar(CapFloorTermVolatilityStructureHandle self) -> Calendar"},
	 { "CapFloorTermVolatilityStructureHandle_referenceDate", _wrap_CapFloorTermVolatilityStructureHandle_referenceDate, METH_O, "CapFloorTermVolatilityStructureHandle_referenceDate(CapFloorTermVolatilityStructureHandle self) -> Date"},
	 { "CapFloorTermVolatilityStructureHandle_maxDate", _wrap_CapFloorTermVolatilityStructureHandle_maxDate, METH_O, "CapFloorTermVolatilityStructureHandle_maxDate(CapFloorTermVolatilityStructureHandle self) -> Date"},
	 { "CapFloorTermVolatilityStructureHandle_maxTime", _wrap_CapFloorTermVolatilityStructureHandle_maxTime, METH_O, "CapFloorTermVolatilityStructureHandle_maxTime(CapFloorTermVolatilityStructureHandle self) -> Time"},
	 { "CapFloorTermVolatilityStructureHandle_enableExtrapolation", _wrap_CapFloorTermVolatilityStructureHandle_enableExtrapolation, METH_O, "CapFloorTermVolatilityStructureHandle_enableExtrapolation(CapFloorTermVolatilityStructureHandle self)"},
	 { "CapFloorTermVolatilityStructureHandle_disableExtrapolation", _wrap_CapFloorTermVolatilityStructureHandle_disableExtrapolation, METH_O, "CapFloorTermVolatilityStructureHandle_disableExtrapolation(CapFloorTermVolatilityStructureHandle self)"},
	 { "CapFloorTermVolatilityStructureHandle_allowsExtrapolation", _wrap_CapFloorTermVolatilityStructureHandle_allowsExtrapolation, METH_O, "CapFloorTermVolatilityStructureHandle_allowsExtrapolation(CapFloorTermVolatilityStructureHandle self) -> bool"},
	 { "CapFloorTermVolatilityStructureHandle_swigregister", CapFloorTermVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "CapFloorTermVolatilityStructureHandle_swiginit", CapFloorTermVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_RelinkableCapFloorTermVolatilityStructureHandle", _wrap_new_RelinkableCapFloorTermVolatilityStructureHandle, METH_VARARGS, "RelinkableCapFloorTermVolatilityStructureHandle(ext::shared_ptr< CapFloorTermVolatilityStructure > const & arg1=ext::shared_ptr())"},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_linkTo", _wrap_RelinkableCapFloorTermVolatilityStructureHandle_linkTo, METH_VARARGS, "RelinkableCapFloorTermVolatilityStructureHandle_linkTo(RelinkableCapFloorTermVolatilityStructureHandle self, ext::shared_ptr< CapFloorTermVolatilityStructure > const & arg2)"},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_reset", _wrap_RelinkableCapFloorTermVolatilityStructureHandle_reset, METH_O, "RelinkableCapFloorTermVolatilityStructureHandle_reset(RelinkableCapFloorTermVolatilityStructureHandle self)"},
	 { "delete_RelinkableCapFloorTermVolatilityStructureHandle", _wrap_delete_RelinkableCapFloorTermVolatilityStructureHandle, METH_O, "delete_RelinkableCapFloorTermVolatilityStructureHandle(RelinkableCapFloorTermVolatilityStructureHandle self)"},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_swigregister", RelinkableCapFloorTermVolatilityStructureHandle_swigregister, METH_O, NULL},
	 { "RelinkableCapFloorTermVolatilityStructureHandle_swiginit", RelinkableCapFloorTermVolatilityStructureHandle_swiginit, METH_VARARGS, NULL},
	 { "new_CapFloorTermVolCurve", _wrap_new_CapFloorTermVolCurve, METH_VARARGS, "\n"
		"CapFloorTermVolCurve(Date referenceDate, Calendar calendar, BusinessDayConvention bdc, PeriodVector lengths, DoubleVector vols, DayCounter dc=QuantLib::Actual365Fixed())\n"
		"CapFloorTermVolCurve(Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, PeriodVector lengths, DoubleVector vols, DayCounter dc=QuantLib::Actual365Fixed())\n"
		""},
	 { "delete_CapFloorTermVolCurve", _wrap_delete_CapFloorTermVolCurve, METH_O, "delete_CapFloorTermVolCurve(CapFloorTermVolCurve self)"},
	 { "CapFloorTermVolCurve_swigregister", CapFloorTermVolCurve_swigregister, METH_O, NULL},
	 { "CapFloorTermVolCurve_swiginit", CapFloorTermVolCurve_swiginit, METH_VARARGS, NULL},
	 { "new_CapFloorTermVolSurface", _wrap_new_CapFloorTermVolSurface, METH_VARARGS, "\n"
		"CapFloorTermVolSurface(Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, QuoteHandleVectorVector quotes, DayCounter dc=QuantLib::Actual365Fixed())\n"
		"CapFloorTermVolSurface(Date settlementDate, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, QuoteHandleVectorVector quotes, DayCounter dc=QuantLib::Actual365Fixed())\n"
		"CapFloorTermVolSurface(Date settlementDate, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, Matrix volatilities, DayCounter dc=QuantLib::Actual365Fixed())\n"
		"CapFloorTermVolSurface(Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, PeriodVector optionTenors, DoubleVector strikes, Matrix volatilities, DayCounter dc=QuantLib::Actual365Fixed())\n"
		""},
	 { "CapFloorTermVolSurface_maxDate", _wrap_CapFloorTermVolSurface_maxDate, METH_O, "CapFloorTermVolSurface_maxDate(CapFloorTermVolSurface self) -> Date"},
	 { "CapFloorTermVolSurface_minStrike", _wrap_CapFloorTermVolSurface_minStrike, METH_O, "CapFloorTermVolSurface_minStrike(CapFloorTermVolSurface self) -> Real"},
	 { "CapFloorTermVolSurface_maxStrike", _wrap_CapFloorTermVolSurface_maxStrike, METH_O, "CapFloorTermVolSurface_maxStrike(CapFloorTermVolSurface self) -> Real"},
	 { "CapFloorTermVolSurface_optionTenors", _wrap_CapFloorTermVolSurface_optionTenors, METH_O, "CapFloorTermVolSurface_optionTenors(CapFloorTermVolSurface self) -> PeriodVector"},
	 { "CapFloorTermVolSurface_optionDates", _wrap_CapFloorTermVolSurface_optionDates, METH_O, "CapFloorTermVolSurface_optionDates(CapFloorTermVolSurface self) -> DateVector"},
	 { "CapFloorTermVolSurface_optionTimes", _wrap_CapFloorTermVolSurface_optionTimes, METH_O, "CapFloorTermVolSurface_optionTimes(CapFloorTermVolSurface self) -> DoubleVector"},
	 { "CapFloorTermVolSurface_strikes", _wrap_CapFloorTermVolSurface_strikes, METH_O, "CapFloorTermVolSurface_strikes(CapFloorTermVolSurface self) -> DoubleVector"},
	 { "delete_CapFloorTermVolSurface", _wrap_delete_CapFloorTermVolSurface, METH_O, "delete_CapFloorTermVolSurface(CapFloorTermVolSurface self)"},
	 { "CapFloorTermVolSurface_swigregister", CapFloorTermVolSurface_swigregister, METH_O, NULL},
	 { "CapFloorTermVolSurface_swiginit", CapFloorTermVolSurface_swiginit, METH_VARARGS, NULL},
	 { "StrippedOptionletBase_optionletStrikes", _wrap_StrippedOptionletBase_optionletStrikes, METH_VARARGS, "StrippedOptionletBase_optionletStrikes(StrippedOptionletBase self, Size i) -> DoubleVector"},
	 { "StrippedOptionletBase_optionletVolatilities", _wrap_StrippedOptionletBase_optionletVolatilities, METH_VARARGS, "StrippedOptionletBase_optionletVolatilities(StrippedOptionletBase self, Size i) -> DoubleVector"},
	 { "StrippedOptionletBase_optionletFixingDates", _wrap_StrippedOptionletBase_optionletFixingDates, METH_O, "StrippedOptionletBase_optionletFixingDates(StrippedOptionletBase self) -> DateVector"},
	 { "StrippedOptionletBase_optionletFixingTimes", _wrap_StrippedOptionletBase_optionletFixingTimes, METH_O, "StrippedOptionletBase_optionletFixingTimes(StrippedOptionletBase self) -> DoubleVector"},
	 { "StrippedOptionletBase_optionletMaturities", _wrap_StrippedOptionletBase_optionletMaturities, METH_O, "StrippedOptionletBase_optionletMaturities(StrippedOptionletBase self) -> Size"},
	 { "StrippedOptionletBase_atmOptionletRates", _wrap_StrippedOptionletBase_atmOptionletRates, METH_O, "StrippedOptionletBase_atmOptionletRates(StrippedOptionletBase self) -> DoubleVector"},
	 { "StrippedOptionletBase_dayCounter", _wrap_StrippedOptionletBase_dayCounter, METH_O, "StrippedOptionletBase_dayCounter(StrippedOptionletBase self) -> DayCounter"},
	 { "StrippedOptionletBase_calendar", _wrap_StrippedOptionletBase_calendar, METH_O, "StrippedOptionletBase_calendar(StrippedOptionletBase self) -> Calendar"},
	 { "StrippedOptionletBase_settlementDays", _wrap_StrippedOptionletBase_settlementDays, METH_O, "StrippedOptionletBase_settlementDays(StrippedOptionletBase self) -> Natural"},
	 { "StrippedOptionletBase_businessDayConvention", _wrap_StrippedOptionletBase_businessDayConvention, METH_O, "StrippedOptionletBase_businessDayConvention(StrippedOptionletBase self) -> BusinessDayConvention"},
	 { "StrippedOptionletBase_volatilityType", _wrap_StrippedOptionletBase_volatilityType, METH_O, "StrippedOptionletBase_volatilityType(StrippedOptionletBase self) -> VolatilityType"},
	 { "StrippedOptionletBase_displacement", _wrap_StrippedOptionletBase_displacement, METH_O, "StrippedOptionletBase_displacement(StrippedOptionletBase self) -> Real"},
	 { "delete_StrippedOptionletBase", _wrap_delete_StrippedOptionletBase, METH_O, "delete_StrippedOptionletBase(StrippedOptionletBase self)"},
	 { "StrippedOptionletBase_swigregister", StrippedOptionletBase_swigregister, METH_O, NULL},
	 { "new_StrippedOptionlet", (PyCFunction)(void(*)(void))_wrap_new_StrippedOptionlet, METH_VARARGS|METH_KEYWORDS, "new_StrippedOptionlet(Natural settlementDays, Calendar calendar, BusinessDayConvention bdc, ext::shared_ptr< IborIndex > iborIndex, DateVector optionletDates, DoubleVector strikes, QuoteHandleVectorVector volatilities, DayCounter dc, VolatilityType type=ShiftedLognormal, Real displacement=0.0) -> StrippedOptionlet"},
	 { "delete_StrippedOptionlet", _wrap_delete_StrippedOptionlet, METH_O, "delete_StrippedOptionlet(StrippedOptionlet self)"},
	 { "StrippedOptionlet_swigregister", StrippedOptionlet_swigregister, METH_O, NULL},
	 { "StrippedOptionlet_swiginit", StrippedOptionlet_swiginit, METH_VARARGS, NULL},
	 { "new_OptionletStripper1", (PyCFunction)(void(*)(void))_wrap_new_OptionletStripper1, METH_VARARGS|METH_KEYWORDS, "new_OptionletStripper1(ext::shared_ptr< CapFloorTermVolSurface > const & parVolSurface, ext::shared_ptr< IborIndex > const & index, Rate switchStrikes=Null< Rate >(), Real accuracy=1.0e-6, Natural maxIter=100, YieldTermStructureHandle discount=Handle< YieldTermStructure >(), VolatilityType type=ShiftedLognormal, Real displacement=0.0, bool dontThrow=False) -> OptionletStripper1"},
	 { "OptionletStripper1_capFloorPrices", _wrap_OptionletStripper1_capFloorPrices, METH_O, "OptionletStripper1_capFloorPrices(OptionletStripper1 self) -> Matrix"},
	 { "OptionletStripper1_capFloorVolatilities", _wrap_OptionletStripper1_capFloorVolatilities, METH_O, "OptionletStripper1_capFloorVolatilities(OptionletStripper1 self) -> Matrix"},
	 { "OptionletStripper1_optionletPrices", _wrap_OptionletStripper1_optionletPrices, METH_O, "OptionletStripper1_optionletPrices(OptionletStripper1 self) -> Matrix"},
	 { "OptionletStripper1_switchStrike", _wrap_OptionletStripper1_switchStrike, METH_O, "OptionletStripper1_switchStrike(OptionletStripper1 self) -> Rate"},
	 { "delete_OptionletStripper1", _wrap_delete_OptionletStripper1, METH_O, "delete_OptionletStripper1(OptionletStripper1 self)"},
	 { "OptionletStripper1_swigregister", OptionletStripper1_swigregister, METH_O, NULL},
	 { "OptionletStripper1_swiginit", OptionletStripper1_swiginit, METH_VARARGS, NULL},
	 { "new_StrippedOptionletAdapter", _wrap_new_StrippedOptionletAdapter, METH_O, "new_StrippedOptionletAdapter(ext::shared_ptr< StrippedOptionletBase > const & arg1) -> StrippedOptionletAdapter"},
	 { "delete_StrippedOptionletAdapter", _wrap_delete_StrippedOptionletAdapter, METH_O, "delete_StrippedOptionletAdapter(StrippedOptionletAdapter self)"},
	 { "StrippedOptionletAdapter_swigregister", StrippedOptionletAdapter_swigregister, METH_O, NULL},
	 { "StrippedOptionletAdapter_swiginit", StrippedOptionletAdapter_swiginit, METH_VARARGS, NULL},
	 { "new_Settlement", _wrap_new_Settlement, METH_NOARGS, "new_Settlement() -> Settlement"},
	 { "delete_Settlement", _wrap_delete_Settlement, METH_O, "delete_Settlement(Settlement self)"},
	 { "Settlement_swigregister", Settlement_swigregister, METH_O, NULL},
	 { "Settlement_swiginit", Settlement_swiginit, METH_VARARGS, NULL},
	 { "new_Swaption", _wrap_new_Swaption, METH_VARARGS, "Swaption(ext::shared_ptr< VanillaSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, Settlement::Type type=Physical, Settlement::Method settlementMethod=PhysicalOTC)"},
	 { "Swaption_settlementType", _wrap_Swaption_settlementType, METH_O, "Swaption_settlementType(Swaption self) -> Settlement::Type"},
	 { "Swaption_settlementMethod", _wrap_Swaption_settlementMethod, METH_O, "Swaption_settlementMethod(Swaption self) -> Settlement::Method"},
	 { "Swaption_type", _wrap_Swaption_type, METH_O, "Swaption_type(Swaption self) -> VanillaSwap::Type"},
	 { "Swaption_underlyingSwap", _wrap_Swaption_underlyingSwap, METH_O, "Swaption_underlyingSwap(Swaption self) -> ext::shared_ptr< VanillaSwap > const &"},
	 { "Swaption_impliedVolatility", _wrap_Swaption_impliedVolatility, METH_VARARGS, "Swaption_impliedVolatility(Swaption self, Real price, YieldTermStructureHandle discountCurve, Volatility guess, Real accuracy=1.0e-4, Natural maxEvaluations=100, Volatility minVol=1.0e-7, Volatility maxVol=4.0, VolatilityType type=ShiftedLognormal, Real displacement=0.0) -> Volatility"},
	 { "Swaption_vega", _wrap_Swaption_vega, METH_O, "Swaption_vega(Swaption self) -> Real"},
	 { "Swaption_delta", _wrap_Swaption_delta, METH_O, "Swaption_delta(Swaption self) -> Real"},
	 { "Swaption_annuity", _wrap_Swaption_annuity, METH_O, "Swaption_annuity(Swaption self) -> Real"},
	 { "delete_Swaption", _wrap_delete_Swaption, METH_O, "delete_Swaption(Swaption self)"},
	 { "Swaption_swigregister", Swaption_swigregister, METH_O, NULL},
	 { "Swaption_swiginit", Swaption_swiginit, METH_VARARGS, NULL},
	 { "new_NonstandardSwaption", _wrap_new_NonstandardSwaption, METH_VARARGS, "NonstandardSwaption(ext::shared_ptr< NonstandardSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, Settlement::Type type=Physical, Settlement::Method settlementMethod=PhysicalOTC)"},
	 { "NonstandardSwaption_underlyingSwap", _wrap_NonstandardSwaption_underlyingSwap, METH_O, "NonstandardSwaption_underlyingSwap(NonstandardSwaption self) -> ext::shared_ptr< NonstandardSwap > const &"},
	 { "NonstandardSwaption_calibrationBasket", _wrap_NonstandardSwaption_calibrationBasket, METH_VARARGS, "NonstandardSwaption_calibrationBasket(NonstandardSwaption self, ext::shared_ptr< SwapIndex > swapIndex, ext::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility, std::string typeStr) -> BlackCalibrationHelperVector"},
	 { "NonstandardSwaption_probabilities", _wrap_NonstandardSwaption_probabilities, METH_O, "NonstandardSwaption_probabilities(NonstandardSwaption self) -> DoubleVector"},
	 { "delete_NonstandardSwaption", _wrap_delete_NonstandardSwaption, METH_O, "delete_NonstandardSwaption(NonstandardSwaption self)"},
	 { "NonstandardSwaption_swigregister", NonstandardSwaption_swigregister, METH_O, NULL},
	 { "NonstandardSwaption_swiginit", NonstandardSwaption_swiginit, METH_VARARGS, NULL},
	 { "new_FloatFloatSwaption", _wrap_new_FloatFloatSwaption, METH_VARARGS, "FloatFloatSwaption(ext::shared_ptr< FloatFloatSwap > const & swap, ext::shared_ptr< Exercise > const & exercise, Settlement::Type delivery=Physical, Settlement::Method settlementMethod=PhysicalOTC)"},
	 { "FloatFloatSwaption_underlyingSwap", _wrap_FloatFloatSwaption_underlyingSwap, METH_O, "FloatFloatSwaption_underlyingSwap(FloatFloatSwaption self) -> ext::shared_ptr< FloatFloatSwap > const &"},
	 { "FloatFloatSwaption_calibrationBasket", _wrap_FloatFloatSwaption_calibrationBasket, METH_VARARGS, "FloatFloatSwaption_calibrationBasket(FloatFloatSwaption self, ext::shared_ptr< SwapIndex > swapIndex, ext::shared_ptr< SwaptionVolatilityStructure > swaptionVolatility, std::string typeStr) -> BlackCalibrationHelperVector"},
	 { "FloatFloatSwaption_underlyingValue", _wrap_FloatFloatSwaption_underlyingValue, METH_O, "FloatFloatSwaption_underlyingValue(FloatFloatSwaption self) -> Real"},
	 { "FloatFloatSwaption_probabilities", _wrap_FloatFloatSwaption_probabilities, METH_O, "FloatFloatSwaption_probabilities(FloatFloatSwaption self) -> DoubleVector"},
	 { "delete_FloatFloatSwaption", _wrap_delete_FloatFloatSwaption, METH_O, "delete_FloatFloatSwaption(FloatFloatSwaption self)"},
	 { "FloatFloatSwaption_swigregister", FloatFloatSwaption_swigregister, METH_O, NULL},
	 { "FloatFloatSwaption_swiginit", FloatFloatSwaption_swiginit, METH_VARARGS, NULL},
	 { "new_BlackSwaptionEngine", _wrap_new_BlackSwaptionEngine, METH_VARARGS, "\n"
		"BlackSwaptionEngine(YieldTermStructureHandle discountCurve, QuoteHandle vol, DayCounter dc=Actual365Fixed(), Real displacement=0.0)\n"
		"new_BlackSwaptionEngine(YieldTermStructureHandle discountCurve, SwaptionVolatilityStructureHandle v) -> BlackSwaptionEngine\n"
		""},
	 { "delete_BlackSwaptionEngine", _wrap_delete_BlackSwaptionEngine, METH_O, "delete_BlackSwaptionEngine(BlackSwaptionEngine self)"},
	 { "BlackSwaptionEngine_swigregister", BlackSwaptionEngine_swigregister, METH_O, NULL},
	 { "BlackSwaptionEngine_swiginit", BlackSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_BachelierSwaptionEngine", _wrap_new_BachelierSwaptionEngine, METH_VARARGS, "\n"
		"BachelierSwaptionEngine(YieldTermStructureHandle discountCurve, QuoteHandle vol, DayCounter dc=Actual365Fixed())\n"
		"new_BachelierSwaptionEngine(YieldTermStructureHandle discountCurve, SwaptionVolatilityStructureHandle v) -> BachelierSwaptionEngine\n"
		""},
	 { "delete_BachelierSwaptionEngine", _wrap_delete_BachelierSwaptionEngine, METH_O, "delete_BachelierSwaptionEngine(BachelierSwaptionEngine self)"},
	 { "BachelierSwaptionEngine_swigregister", BachelierSwaptionEngine_swigregister, METH_O, NULL},
	 { "BachelierSwaptionEngine_swiginit", BachelierSwaptionEngine_swiginit, METH_VARARGS, NULL},
	 { "new_VanillaSwingOption", _wrap_new_VanillaSwingOption, METH_VARARGS, "new_VanillaSwingOption(ext::shared_ptr< Payoff > const & payoff, ext::shared_ptr< SwingExercise > const & ex, Size minExerciseRights, Size maxExerciseRights) -> VanillaSwingOption"},
	 { "delete_VanillaSwingOption", _wrap_delete_VanillaSwingOption, METH_O, "delete_VanillaSwingOption(VanillaSwingOption self)"},
	 { "VanillaSwingOption_swigregister", VanillaSwingOption_swigregister, METH_O, NULL},
	 { "VanillaSwingOption_swiginit", VanillaSwingOption_swiginit, METH_VARARGS, NULL},
	 { "new_FdSimpleBSSwingEngine", _wrap_new_FdSimpleBSSwingEngine, METH_VARARGS, "FdSimpleBSSwingEngine(ext::shared_ptr< GeneralizedBlackScholesProcess > const & process, Size tGrid=50, Size xGrid=100, FdmSchemeDesc schemeDesc=FdmSchemeDesc::Douglas())"},
	 { "delete_FdSimpleBSSwingEngine", _wrap_delete_FdSimpleBSSwingEngine, METH_O, "delete_FdSimpleBSSwingEngine(FdSimpleBSSwingEngine self)"},
	 { "FdSimpleBSSwingEngine_swigregister", FdSimpleBSSwingEngine_swigregister, METH_O, NULL},
	 { "FdSimpleBSSwingEngine_swiginit", FdSimpleBSSwingEngine_swiginit, METH_VARARGS, NULL},
	 { "new_FdSimpleExtOUJumpSwingEngine", _wrap_new_FdSimpleExtOUJumpSwingEngine, METH_VARARGS, "FdSimpleExtOUJumpSwingEngine(ext::shared_ptr< ExtOUWithJumpsProcess > const & process, ext::shared_ptr< YieldTermStructure > const & rTS, Size tGrid=50, Size xGrid=200, Size yGrid=50, DoublePairVector shape=std::vector< std::pair< Time,Real > >(), FdmSchemeDesc schemeDesc=FdmSchemeDesc::Hundsdorfer())"},
	 { "delete_FdSimpleExtOUJumpSwingEngine", _wrap_delete_FdSimpleExtOUJumpSwingEngine, METH_O, "delete_FdSimpleExtOUJumpSwingEngine(FdSimpleExtOUJumpSwingEngine self)"},
	 { "FdSimpleExtOUJumpSwingEngine_swigregister", FdSimpleExtOUJumpSwingEngine_swigregister, METH_O, NULL},
	 { "FdSimpleExtOUJumpSwingEngine_swiginit", FdSimpleExtOUJumpSwingEngine_swiginit, METH_VARARGS, NULL},
	 { "enableTracing", _wrap_enableTracing, METH_NOARGS, "enableTracing()"},
	 { "disableTracing", _wrap_disableTracing, METH_NOARGS, "disableTracing()"},
	 { "new_ConstantEstimator", _wrap_new_ConstantEstimator, METH_O, "new_ConstantEstimator(Size size) -> ConstantEstimator"},
	 { "ConstantEstimator_calculate", _wrap_ConstantEstimator_calculate, METH_VARARGS, "ConstantEstimator_calculate(ConstantEstimator self, RealTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_ConstantEstimator", _wrap_delete_ConstantEstimator, METH_O, "delete_ConstantEstimator(ConstantEstimator self)"},
	 { "ConstantEstimator_swigregister", ConstantEstimator_swigregister, METH_O, NULL},
	 { "ConstantEstimator_swiginit", ConstantEstimator_swiginit, METH_VARARGS, NULL},
	 { "new_ParkinsonSigma", _wrap_new_ParkinsonSigma, METH_O, "new_ParkinsonSigma(Real yearFraction) -> ParkinsonSigma"},
	 { "ParkinsonSigma_calculate", _wrap_ParkinsonSigma_calculate, METH_VARARGS, "ParkinsonSigma_calculate(ParkinsonSigma self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_ParkinsonSigma", _wrap_delete_ParkinsonSigma, METH_O, "delete_ParkinsonSigma(ParkinsonSigma self)"},
	 { "ParkinsonSigma_swigregister", ParkinsonSigma_swigregister, METH_O, NULL},
	 { "ParkinsonSigma_swiginit", ParkinsonSigma_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma1", _wrap_new_GarmanKlassSigma1, METH_VARARGS, "new_GarmanKlassSigma1(Real yearFraction, Real marketOpenFraction) -> GarmanKlassSigma1"},
	 { "GarmanKlassSigma1_calculate", _wrap_GarmanKlassSigma1_calculate, METH_VARARGS, "GarmanKlassSigma1_calculate(GarmanKlassSigma1 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_GarmanKlassSigma1", _wrap_delete_GarmanKlassSigma1, METH_O, "delete_GarmanKlassSigma1(GarmanKlassSigma1 self)"},
	 { "GarmanKlassSigma1_swigregister", GarmanKlassSigma1_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma1_swiginit", GarmanKlassSigma1_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma3", _wrap_new_GarmanKlassSigma3, METH_VARARGS, "new_GarmanKlassSigma3(Real yearFraction, Real marketOpenFraction) -> GarmanKlassSigma3"},
	 { "GarmanKlassSigma3_calculate", _wrap_GarmanKlassSigma3_calculate, METH_VARARGS, "GarmanKlassSigma3_calculate(GarmanKlassSigma3 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_GarmanKlassSigma3", _wrap_delete_GarmanKlassSigma3, METH_O, "delete_GarmanKlassSigma3(GarmanKlassSigma3 self)"},
	 { "GarmanKlassSigma3_swigregister", GarmanKlassSigma3_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma3_swiginit", GarmanKlassSigma3_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma4", _wrap_new_GarmanKlassSigma4, METH_O, "new_GarmanKlassSigma4(Real yearFraction) -> GarmanKlassSigma4"},
	 { "GarmanKlassSigma4_calculate", _wrap_GarmanKlassSigma4_calculate, METH_VARARGS, "GarmanKlassSigma4_calculate(GarmanKlassSigma4 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_GarmanKlassSigma4", _wrap_delete_GarmanKlassSigma4, METH_O, "delete_GarmanKlassSigma4(GarmanKlassSigma4 self)"},
	 { "GarmanKlassSigma4_swigregister", GarmanKlassSigma4_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma4_swiginit", GarmanKlassSigma4_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma5", _wrap_new_GarmanKlassSigma5, METH_O, "new_GarmanKlassSigma5(Real yearFraction) -> GarmanKlassSigma5"},
	 { "GarmanKlassSigma5_calculate", _wrap_GarmanKlassSigma5_calculate, METH_VARARGS, "GarmanKlassSigma5_calculate(GarmanKlassSigma5 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_GarmanKlassSigma5", _wrap_delete_GarmanKlassSigma5, METH_O, "delete_GarmanKlassSigma5(GarmanKlassSigma5 self)"},
	 { "GarmanKlassSigma5_swigregister", GarmanKlassSigma5_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma5_swiginit", GarmanKlassSigma5_swiginit, METH_VARARGS, NULL},
	 { "new_GarmanKlassSigma6", _wrap_new_GarmanKlassSigma6, METH_VARARGS, "new_GarmanKlassSigma6(Real yearFraction, Real marketOpenFraction) -> GarmanKlassSigma6"},
	 { "GarmanKlassSigma6_calculate", _wrap_GarmanKlassSigma6_calculate, METH_VARARGS, "GarmanKlassSigma6_calculate(GarmanKlassSigma6 self, IntervalPriceTimeSeries arg2) -> RealTimeSeries"},
	 { "delete_GarmanKlassSigma6", _wrap_delete_GarmanKlassSigma6, METH_O, "delete_GarmanKlassSigma6(GarmanKlassSigma6 self)"},
	 { "GarmanKlassSigma6_swigregister", GarmanKlassSigma6_swigregister, METH_O, NULL},
	 { "GarmanKlassSigma6_swiginit", GarmanKlassSigma6_swiginit, METH_VARARGS, NULL},
	 { "new_ZeroCurve", _wrap_new_ZeroCurve, METH_VARARGS, "ZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), Linear i=Linear(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "ZeroCurve_times", _wrap_ZeroCurve_times, METH_O, "ZeroCurve_times(ZeroCurve self) -> DoubleVector"},
	 { "ZeroCurve_data", _wrap_ZeroCurve_data, METH_O, "ZeroCurve_data(ZeroCurve self) -> DoubleVector"},
	 { "ZeroCurve_dates", _wrap_ZeroCurve_dates, METH_O, "ZeroCurve_dates(ZeroCurve self) -> DateVector"},
	 { "ZeroCurve_zeroRates", _wrap_ZeroCurve_zeroRates, METH_O, "ZeroCurve_zeroRates(ZeroCurve self) -> DoubleVector"},
	 { "ZeroCurve_nodes", _wrap_ZeroCurve_nodes, METH_O, "ZeroCurve_nodes(ZeroCurve self) -> NodeVector"},
	 { "delete_ZeroCurve", _wrap_delete_ZeroCurve, METH_O, "delete_ZeroCurve(ZeroCurve self)"},
	 { "ZeroCurve_swigregister", ZeroCurve_swigregister, METH_O, NULL},
	 { "ZeroCurve_swiginit", ZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_LogLinearZeroCurve", _wrap_new_LogLinearZeroCurve, METH_VARARGS, "LogLinearZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), LogLinear i=LogLinear(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "LogLinearZeroCurve_times", _wrap_LogLinearZeroCurve_times, METH_O, "LogLinearZeroCurve_times(LogLinearZeroCurve self) -> DoubleVector"},
	 { "LogLinearZeroCurve_data", _wrap_LogLinearZeroCurve_data, METH_O, "LogLinearZeroCurve_data(LogLinearZeroCurve self) -> DoubleVector"},
	 { "LogLinearZeroCurve_dates", _wrap_LogLinearZeroCurve_dates, METH_O, "LogLinearZeroCurve_dates(LogLinearZeroCurve self) -> DateVector"},
	 { "LogLinearZeroCurve_zeroRates", _wrap_LogLinearZeroCurve_zeroRates, METH_O, "LogLinearZeroCurve_zeroRates(LogLinearZeroCurve self) -> DoubleVector"},
	 { "LogLinearZeroCurve_nodes", _wrap_LogLinearZeroCurve_nodes, METH_O, "LogLinearZeroCurve_nodes(LogLinearZeroCurve self) -> NodeVector"},
	 { "delete_LogLinearZeroCurve", _wrap_delete_LogLinearZeroCurve, METH_O, "delete_LogLinearZeroCurve(LogLinearZeroCurve self)"},
	 { "LogLinearZeroCurve_swigregister", LogLinearZeroCurve_swigregister, METH_O, NULL},
	 { "LogLinearZeroCurve_swiginit", LogLinearZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_CubicZeroCurve", _wrap_new_CubicZeroCurve, METH_VARARGS, "CubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), Cubic i=Cubic(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "CubicZeroCurve_times", _wrap_CubicZeroCurve_times, METH_O, "CubicZeroCurve_times(CubicZeroCurve self) -> DoubleVector"},
	 { "CubicZeroCurve_data", _wrap_CubicZeroCurve_data, METH_O, "CubicZeroCurve_data(CubicZeroCurve self) -> DoubleVector"},
	 { "CubicZeroCurve_dates", _wrap_CubicZeroCurve_dates, METH_O, "CubicZeroCurve_dates(CubicZeroCurve self) -> DateVector"},
	 { "CubicZeroCurve_zeroRates", _wrap_CubicZeroCurve_zeroRates, METH_O, "CubicZeroCurve_zeroRates(CubicZeroCurve self) -> DoubleVector"},
	 { "CubicZeroCurve_nodes", _wrap_CubicZeroCurve_nodes, METH_O, "CubicZeroCurve_nodes(CubicZeroCurve self) -> NodeVector"},
	 { "delete_CubicZeroCurve", _wrap_delete_CubicZeroCurve, METH_O, "delete_CubicZeroCurve(CubicZeroCurve self)"},
	 { "CubicZeroCurve_swigregister", CubicZeroCurve_swigregister, METH_O, NULL},
	 { "CubicZeroCurve_swiginit", CubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_NaturalCubicZeroCurve", _wrap_new_NaturalCubicZeroCurve, METH_VARARGS, "NaturalCubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), SplineCubic i=SplineCubic(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "NaturalCubicZeroCurve_times", _wrap_NaturalCubicZeroCurve_times, METH_O, "NaturalCubicZeroCurve_times(NaturalCubicZeroCurve self) -> DoubleVector"},
	 { "NaturalCubicZeroCurve_data", _wrap_NaturalCubicZeroCurve_data, METH_O, "NaturalCubicZeroCurve_data(NaturalCubicZeroCurve self) -> DoubleVector"},
	 { "NaturalCubicZeroCurve_dates", _wrap_NaturalCubicZeroCurve_dates, METH_O, "NaturalCubicZeroCurve_dates(NaturalCubicZeroCurve self) -> DateVector"},
	 { "NaturalCubicZeroCurve_zeroRates", _wrap_NaturalCubicZeroCurve_zeroRates, METH_O, "NaturalCubicZeroCurve_zeroRates(NaturalCubicZeroCurve self) -> DoubleVector"},
	 { "NaturalCubicZeroCurve_nodes", _wrap_NaturalCubicZeroCurve_nodes, METH_O, "NaturalCubicZeroCurve_nodes(NaturalCubicZeroCurve self) -> NodeVector"},
	 { "delete_NaturalCubicZeroCurve", _wrap_delete_NaturalCubicZeroCurve, METH_O, "delete_NaturalCubicZeroCurve(NaturalCubicZeroCurve self)"},
	 { "NaturalCubicZeroCurve_swigregister", NaturalCubicZeroCurve_swigregister, METH_O, NULL},
	 { "NaturalCubicZeroCurve_swiginit", NaturalCubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_LogCubicZeroCurve", _wrap_new_LogCubicZeroCurve, METH_VARARGS, "LogCubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), DefaultLogCubic i=DefaultLogCubic(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "LogCubicZeroCurve_times", _wrap_LogCubicZeroCurve_times, METH_O, "LogCubicZeroCurve_times(LogCubicZeroCurve self) -> DoubleVector"},
	 { "LogCubicZeroCurve_data", _wrap_LogCubicZeroCurve_data, METH_O, "LogCubicZeroCurve_data(LogCubicZeroCurve self) -> DoubleVector"},
	 { "LogCubicZeroCurve_dates", _wrap_LogCubicZeroCurve_dates, METH_O, "LogCubicZeroCurve_dates(LogCubicZeroCurve self) -> DateVector"},
	 { "LogCubicZeroCurve_zeroRates", _wrap_LogCubicZeroCurve_zeroRates, METH_O, "LogCubicZeroCurve_zeroRates(LogCubicZeroCurve self) -> DoubleVector"},
	 { "LogCubicZeroCurve_nodes", _wrap_LogCubicZeroCurve_nodes, METH_O, "LogCubicZeroCurve_nodes(LogCubicZeroCurve self) -> NodeVector"},
	 { "delete_LogCubicZeroCurve", _wrap_delete_LogCubicZeroCurve, METH_O, "delete_LogCubicZeroCurve(LogCubicZeroCurve self)"},
	 { "LogCubicZeroCurve_swigregister", LogCubicZeroCurve_swigregister, METH_O, NULL},
	 { "LogCubicZeroCurve_swiginit", LogCubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_MonotonicCubicZeroCurve", _wrap_new_MonotonicCubicZeroCurve, METH_VARARGS, "MonotonicCubicZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), MonotonicCubic i=MonotonicCubic(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "MonotonicCubicZeroCurve_times", _wrap_MonotonicCubicZeroCurve_times, METH_O, "MonotonicCubicZeroCurve_times(MonotonicCubicZeroCurve self) -> DoubleVector"},
	 { "MonotonicCubicZeroCurve_data", _wrap_MonotonicCubicZeroCurve_data, METH_O, "MonotonicCubicZeroCurve_data(MonotonicCubicZeroCurve self) -> DoubleVector"},
	 { "MonotonicCubicZeroCurve_dates", _wrap_MonotonicCubicZeroCurve_dates, METH_O, "MonotonicCubicZeroCurve_dates(MonotonicCubicZeroCurve self) -> DateVector"},
	 { "MonotonicCubicZeroCurve_zeroRates", _wrap_MonotonicCubicZeroCurve_zeroRates, METH_O, "MonotonicCubicZeroCurve_zeroRates(MonotonicCubicZeroCurve self) -> DoubleVector"},
	 { "MonotonicCubicZeroCurve_nodes", _wrap_MonotonicCubicZeroCurve_nodes, METH_O, "MonotonicCubicZeroCurve_nodes(MonotonicCubicZeroCurve self) -> NodeVector"},
	 { "delete_MonotonicCubicZeroCurve", _wrap_delete_MonotonicCubicZeroCurve, METH_O, "delete_MonotonicCubicZeroCurve(MonotonicCubicZeroCurve self)"},
	 { "MonotonicCubicZeroCurve_swigregister", MonotonicCubicZeroCurve_swigregister, METH_O, NULL},
	 { "MonotonicCubicZeroCurve_swiginit", MonotonicCubicZeroCurve_swiginit, METH_VARARGS, NULL},
	 { "new_KrugerZeroCurve", _wrap_new_KrugerZeroCurve, METH_VARARGS, "KrugerZeroCurve(DateVector dates, DoubleVector yields, DayCounter dayCounter, Calendar calendar=Calendar(), Kruger i=Kruger(), Compounding compounding=Continuous, Frequency frequency=Annual)"},
	 { "KrugerZeroCurve_times", _wrap_KrugerZeroCurve_times, METH_O, "KrugerZeroCurve_times(KrugerZeroCurve self) -> DoubleVector"},
	 { "KrugerZeroCurve_data", _wrap_KrugerZeroCurve_data, METH_O, "KrugerZeroCurve_data(KrugerZeroCurve self) -> DoubleVector"},
	 { "KrugerZeroCurve_dates", _wrap_KrugerZeroCurve_dates, METH_O, "KrugerZeroCurve_dates(KrugerZeroCurve self) -> DateVector"},
	 { "KrugerZeroCurve_zeroRates", _wrap_KrugerZeroCurve_zeroRates, METH_O, "KrugerZeroCurve_zeroRates(KrugerZeroCurve self) -> DoubleVector"},
	 { "KrugerZeroCurve_nodes", _wrap_KrugerZeroCurve_nodes, METH_O, "KrugerZeroCurve_nodes(KrugerZeroCurve self) -> NodeVector"},
	 { "delete_KrugerZeroCurve", _wrap_delete_KrugerZeroCurve, METH_O, "delete_KrugerZeroCurve(KrugerZeroCurve self)"},
	 { "KrugerZeroCurve_swigregister", KrugerZeroCurve_swigregister, METH_O, NULL},
	 { "KrugerZeroCurve_swiginit", KrugerZeroCurve_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_AbcdFunctionTo_p_AbcdMathFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((AbcdMathFunction *)  ((AbcdFunction *) x));
}
static void *_p_PartialBarrierTo_p_Barrier(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Barrier *)  ((PartialBarrier *) x));
}
static void *_p_DividendBarrierOptionTo_p_BarrierOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BarrierOption *)  ((DividendBarrierOption *) x));
}
static void *_p_QuantoBarrierOptionTo_p_BarrierOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BarrierOption *)  ((QuantoBarrierOption *) x));
}
static void *_p_AverageBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((AverageBasketPayoff *) x));
}
static void *_p_MaxBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((MaxBasketPayoff *) x));
}
static void *_p_MinBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((MinBasketPayoff *) x));
}
static void *_p_SpreadBasketPayoffTo_p_BasketPayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BasketPayoff *)  ((SpreadBasketPayoff *) x));
}
static void *_p_Bbsw1MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw1M *) x));
}
static void *_p_Bbsw2MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw2M *) x));
}
static void *_p_Bbsw3MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw3M *) x));
}
static void *_p_Bbsw4MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw4M *) x));
}
static void *_p_Bbsw5MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw5M *) x));
}
static void *_p_Bbsw6MTo_p_Bbsw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bbsw *)  ((Bbsw6M *) x));
}
static void *_p_Bibor1MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor1M *) x));
}
static void *_p_Bibor1YTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor1Y *) x));
}
static void *_p_Bibor2MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor2M *) x));
}
static void *_p_Bibor3MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor3M *) x));
}
static void *_p_Bibor6MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor6M *) x));
}
static void *_p_Bibor9MTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((Bibor9M *) x));
}
static void *_p_BiborSWTo_p_Bibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bibor *)  ((BiborSW *) x));
}
static void *_p_Bkbm1MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm1M *) x));
}
static void *_p_Bkbm2MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm2M *) x));
}
static void *_p_Bkbm3MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm3M *) x));
}
static void *_p_Bkbm4MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm4M *) x));
}
static void *_p_Bkbm5MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm5M *) x));
}
static void *_p_Bkbm6MTo_p_Bkbm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bkbm *)  ((Bkbm6M *) x));
}
static void *_p_CapHelperTo_p_BlackCalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackCalibrationHelper *)  ((CapHelper *) x));
}
static void *_p_HestonModelHelperTo_p_BlackCalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackCalibrationHelper *)  ((HestonModelHelper *) x));
}
static void *_p_SwaptionHelperTo_p_BlackCalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackCalibrationHelper *)  ((SwaptionHelper *) x));
}
static void *_p_AndreasenHugeVolatilityAdapterTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((AndreasenHugeVolatilityAdapter *) x));
}
static void *_p_BlackConstantVolTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((BlackConstantVol *) x));
}
static void *_p_BlackVarianceCurveTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((BlackVarianceCurve *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((BlackVarianceSurface *) x));
}
static void *_p_HestonBlackVolSurfaceTo_p_BlackVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BlackVolTermStructure *)  ((HestonBlackVolSurface *) x));
}
static void *_p_AmortizingCmsRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((AmortizingCmsRateBond *) x));
}
static void *_p_AmortizingFixedRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((AmortizingFixedRateBond *) x));
}
static void *_p_AmortizingFloatingRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((AmortizingFloatingRateBond *) x));
}
static void *_p_CPIBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((CPIBond *) x));
}
static void *_p_CallableBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((CallableBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *) (CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *) (CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_CmsRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((CmsRateBond *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ConvertibleFixedCouponBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ConvertibleFloatingRateBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ConvertibleZeroCouponBond *) x));
}
static void *_p_FixedRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((FixedRateBond *) x));
}
static void *_p_FloatingRateBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((FloatingRateBond *) x));
}
static void *_p_ZeroCouponBondTo_p_Bond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Bond *)  ((ZeroCouponBond *) x));
}
static void *_p_FixedRateBondForwardTo_p_BondForward(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BondForward *)  ((FixedRateBondForward *) x));
}
static void *_p_FixedRateBondHelperTo_p_BondHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BondHelper *)  ((FixedRateBondHelper *) x));
}
static void *_p_YearOnYearInflationSwapHelperTo_p_BootstrapHelperT_YoYInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BootstrapHelper< YoYInflationTermStructure > *)  ((YearOnYearInflationSwapHelper *) x));
}
static void *_p_YoYOptionletHelperTo_p_BootstrapHelperT_YoYOptionletVolatilitySurface_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BootstrapHelper< YoYOptionletVolatilitySurface > *)  ((YoYOptionletHelper *) x));
}
static void *_p_ZeroCouponInflationSwapHelperTo_p_BootstrapHelperT_ZeroInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BootstrapHelper< ZeroInflationTermStructure > *)  ((ZeroCouponInflationSwapHelper *) x));
}
static void *_p_MTBrownianGeneratorTo_p_BrownianGenerator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BrownianGenerator *)  ((MTBrownianGenerator *) x));
}
static void *_p_SobolBrownianGeneratorTo_p_BrownianGenerator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BrownianGenerator *)  ((SobolBrownianGenerator *) x));
}
static void *_p_MTBrownianGeneratorFactoryTo_p_BrownianGeneratorFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BrownianGeneratorFactory *)  ((MTBrownianGeneratorFactory *) x));
}
static void *_p_SobolBrownianGeneratorFactoryTo_p_BrownianGeneratorFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((BrownianGeneratorFactory *)  ((SobolBrownianGeneratorFactory *) x));
}
static void *_p_QuantLib__ArgentinaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Argentina *) x));
}
static void *_p_QuantLib__AustraliaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Australia *) x));
}
static void *_p_QuantLib__AustriaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Austria *) x));
}
static void *_p_QuantLib__BespokeCalendarTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::BespokeCalendar *) x));
}
static void *_p_QuantLib__BotswanaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Botswana *) x));
}
static void *_p_QuantLib__BrazilTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Brazil *) x));
}
static void *_p_QuantLib__CanadaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Canada *) x));
}
static void *_p_QuantLib__ChileTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Chile *) x));
}
static void *_p_QuantLib__ChinaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::China *) x));
}
static void *_p_QuantLib__CzechRepublicTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::CzechRepublic *) x));
}
static void *_p_QuantLib__DenmarkTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Denmark *) x));
}
static void *_p_QuantLib__FinlandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Finland *) x));
}
static void *_p_QuantLib__FranceTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::France *) x));
}
static void *_p_QuantLib__GermanyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Germany *) x));
}
static void *_p_QuantLib__HongKongTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::HongKong *) x));
}
static void *_p_QuantLib__HungaryTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Hungary *) x));
}
static void *_p_QuantLib__IcelandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Iceland *) x));
}
static void *_p_QuantLib__IndiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::India *) x));
}
static void *_p_QuantLib__IndonesiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Indonesia *) x));
}
static void *_p_QuantLib__IsraelTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Israel *) x));
}
static void *_p_QuantLib__ItalyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Italy *) x));
}
static void *_p_QuantLib__JapanTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Japan *) x));
}
static void *_p_QuantLib__JointCalendarTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::JointCalendar *) x));
}
static void *_p_QuantLib__MexicoTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Mexico *) x));
}
static void *_p_QuantLib__NewZealandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::NewZealand *) x));
}
static void *_p_QuantLib__NorwayTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Norway *) x));
}
static void *_p_QuantLib__NullCalendarTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::NullCalendar *) x));
}
static void *_p_QuantLib__PolandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Poland *) x));
}
static void *_p_QuantLib__RomaniaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Romania *) x));
}
static void *_p_QuantLib__RussiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Russia *) x));
}
static void *_p_QuantLib__SaudiArabiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::SaudiArabia *) x));
}
static void *_p_QuantLib__SingaporeTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Singapore *) x));
}
static void *_p_QuantLib__SlovakiaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Slovakia *) x));
}
static void *_p_QuantLib__SouthAfricaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::SouthAfrica *) x));
}
static void *_p_QuantLib__SouthKoreaTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::SouthKorea *) x));
}
static void *_p_QuantLib__SwedenTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Sweden *) x));
}
static void *_p_QuantLib__SwitzerlandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Switzerland *) x));
}
static void *_p_QuantLib__TARGETTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::TARGET *) x));
}
static void *_p_QuantLib__TaiwanTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Taiwan *) x));
}
static void *_p_QuantLib__ThailandTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Thailand *) x));
}
static void *_p_QuantLib__TurkeyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Turkey *) x));
}
static void *_p_QuantLib__UkraineTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::Ukraine *) x));
}
static void *_p_QuantLib__UnitedKingdomTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::UnitedKingdom *) x));
}
static void *_p_QuantLib__UnitedStatesTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::UnitedStates *) x));
}
static void *_p_QuantLib__WeekendsOnlyTo_p_Calendar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Calendar *)  ((QuantLib::WeekendsOnly *) x));
}
static void *_p_BatesModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (HestonModel *) ((BatesModel *) x));
}
static void *_p_BlackKarasinskiTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((BlackKarasinski *) x));
}
static void *_p_CoxIngersollRossTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((CoxIngersollRoss *) x));
}
static void *_p_ExtendedCoxIngersollRossTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((ExtendedCoxIngersollRoss *) x));
}
static void *_p_G2To_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((G2 *) x));
}
static void *_p_GJRGARCHModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((GJRGARCHModel *) x));
}
static void *_p_GridModelLocalVolSurfaceTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((GridModelLocalVolSurface *) x));
}
static void *_p_HestonModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((HestonModel *) x));
}
static void *_p_HullWhiteTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *)(OneFactorAffineModel *)(Vasicek *) ((HullWhite *) x));
}
static void *_p_OneFactorAffineModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *) ((OneFactorAffineModel *) x));
}
static void *_p_PiecewiseTimeDependentHestonModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((PiecewiseTimeDependentHestonModel *) x));
}
static void *_p_ShortRateModelTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *)  ((ShortRateModel *) x));
}
static void *_p_VasicekTo_p_CalibratedModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibratedModel *) (ShortRateModel *)(OneFactorAffineModel *) ((Vasicek *) x));
}
static void *_p_BlackCalibrationHelperTo_p_CalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibrationHelper *)  ((BlackCalibrationHelper *) x));
}
static void *_p_CapHelperTo_p_CalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibrationHelper *) (BlackCalibrationHelper *) ((CapHelper *) x));
}
static void *_p_HestonModelHelperTo_p_CalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibrationHelper *) (BlackCalibrationHelper *) ((HestonModelHelper *) x));
}
static void *_p_SwaptionHelperTo_p_CalibrationHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CalibrationHelper *) (BlackCalibrationHelper *) ((SwaptionHelper *) x));
}
static void *_p_SoftCallabilityTo_p_Callability(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Callability *)  ((SoftCallability *) x));
}
static void *_p_CallableFixedRateBondTo_p_CallableBond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CallableBond *)  ((CallableFixedRateBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_CallableBond(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CallableBond *)  ((CallableZeroCouponBond *) x));
}
static void *_p_CapTo_p_CapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloor *)  ((Cap *) x));
}
static void *_p_CollarTo_p_CapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloor *)  ((Collar *) x));
}
static void *_p_FloorTo_p_CapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloor *)  ((Floor *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_CapFloorTermVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloorTermVolatilityStructure *)  ((CapFloorTermVolCurve *) x));
}
static void *_p_CapFloorTermVolSurfaceTo_p_CapFloorTermVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CapFloorTermVolatilityStructure *)  ((CapFloorTermVolSurface *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_CappedFlooredCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CappedFlooredCoupon *)  ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_CappedFlooredCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CappedFlooredCoupon *)  ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_CappedFlooredCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CappedFlooredCoupon *)  ((CappedFlooredIborCoupon *) x));
}
static void *_p_AmortizingPaymentTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((AmortizingPayment *) x));
}
static void *_p_CPICashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (IndexedCashFlow *) ((CPICashFlow *) x));
}
static void *_p_CPICouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(InflationCoupon *) ((CPICoupon *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((CappedFlooredCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_CappedFlooredYoYInflationCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(InflationCoupon *)(YoYInflationCoupon *) ((CappedFlooredYoYInflationCoupon *) x));
}
static void *_p_CmsCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((CmsCoupon *) x));
}
static void *_p_CmsSpreadCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((CmsSpreadCoupon *) x));
}
static void *_p_CouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((Coupon *) x));
}
static void *_p_DividendTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((Dividend *) x));
}
static void *_p_EquityCashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (IndexedCashFlow *) ((EquityCashFlow *) x));
}
static void *_p_FixedDividendTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Dividend *) ((FixedDividend *) x));
}
static void *_p_FixedRateCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *) ((FixedRateCoupon *) x));
}
static void *_p_FloatingRateCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *) ((FloatingRateCoupon *) x));
}
static void *_p_FractionalDividendTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Dividend *) ((FractionalDividend *) x));
}
static void *_p_IborCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((IborCoupon *) x));
}
static void *_p_IndexedCashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((IndexedCashFlow *) x));
}
static void *_p_InflationCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *) ((InflationCoupon *) x));
}
static void *_p_OvernightIndexedCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((OvernightIndexedCoupon *) x));
}
static void *_p_RedemptionTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((Redemption *) x));
}
static void *_p_SimpleCashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((SimpleCashFlow *) x));
}
static void *_p_SubPeriodsCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(FloatingRateCoupon *) ((SubPeriodsCoupon *) x));
}
static void *_p_YoYInflationCouponTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *) (Coupon *)(InflationCoupon *) ((YoYInflationCoupon *) x));
}
static void *_p_ZeroInflationCashFlowTo_p_CashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CashFlow *)  ((ZeroInflationCashFlow *) x));
}
static void *_p_FaceValueAccrualClaimTo_p_Claim(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Claim *)  ((FaceValueAccrualClaim *) x));
}
static void *_p_FaceValueClaimTo_p_Claim(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Claim *)  ((FaceValueClaim *) x));
}
static void *_p_AnalyticHaganPricerTo_p_CmsCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsCouponPricer *)  ((AnalyticHaganPricer *) x));
}
static void *_p_LinearTsrPricerTo_p_CmsCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsCouponPricer *)  ((LinearTsrPricer *) x));
}
static void *_p_NumericHaganPricerTo_p_CmsCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsCouponPricer *)  ((NumericHaganPricer *) x));
}
static void *_p_LognormalCmsSpreadPricerTo_p_CmsSpreadCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CmsSpreadCouponPricer *)  ((LognormalCmsSpreadPricer *) x));
}
static void *_p_BoundaryConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((BoundaryConstraint *) x));
}
static void *_p_CompositeConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((CompositeConstraint *) x));
}
static void *_p_NoConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((NoConstraint *) x));
}
static void *_p_NonhomogeneousBoundaryConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((NonhomogeneousBoundaryConstraint *) x));
}
static void *_p_PositiveConstraintTo_p_Constraint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Constraint *)  ((PositiveConstraint *) x));
}
static void *_p_ContinuousPartialFixedLookbackOptionTo_p_ContinuousFixedLookbackOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ContinuousFixedLookbackOption *)  ((ContinuousPartialFixedLookbackOption *) x));
}
static void *_p_ContinuousPartialFloatingLookbackOptionTo_p_ContinuousFloatingLookbackOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ContinuousFloatingLookbackOption *)  ((ContinuousPartialFloatingLookbackOption *) x));
}
static void *_p_CPICouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (InflationCoupon *) ((CPICoupon *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((CappedFlooredCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_CappedFlooredYoYInflationCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (InflationCoupon *)(YoYInflationCoupon *) ((CappedFlooredYoYInflationCoupon *) x));
}
static void *_p_CmsCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((CmsCoupon *) x));
}
static void *_p_CmsSpreadCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((CmsSpreadCoupon *) x));
}
static void *_p_FixedRateCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *)  ((FixedRateCoupon *) x));
}
static void *_p_FloatingRateCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *)  ((FloatingRateCoupon *) x));
}
static void *_p_IborCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((IborCoupon *) x));
}
static void *_p_InflationCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *)  ((InflationCoupon *) x));
}
static void *_p_OvernightIndexedCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((OvernightIndexedCoupon *) x));
}
static void *_p_SubPeriodsCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (FloatingRateCoupon *) ((SubPeriodsCoupon *) x));
}
static void *_p_YoYInflationCouponTo_p_Coupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Coupon *) (InflationCoupon *) ((YoYInflationCoupon *) x));
}
static void *_p_QuantLib__AEDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::AEDCurrency *) x));
}
static void *_p_QuantLib__AOACurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::AOACurrency *) x));
}
static void *_p_QuantLib__ARSCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ARSCurrency *) x));
}
static void *_p_QuantLib__ATSCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ATSCurrency *) x));
}
static void *_p_QuantLib__AUDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::AUDCurrency *) x));
}
static void *_p_QuantLib__BCHCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BCHCurrency *) x));
}
static void *_p_QuantLib__BDTCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BDTCurrency *) x));
}
static void *_p_QuantLib__BEFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BEFCurrency *) x));
}
static void *_p_QuantLib__BGLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BGLCurrency *) x));
}
static void *_p_QuantLib__BGNCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BGNCurrency *) x));
}
static void *_p_QuantLib__BHDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BHDCurrency *) x));
}
static void *_p_QuantLib__BRLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BRLCurrency *) x));
}
static void *_p_QuantLib__BTCCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BTCCurrency *) x));
}
static void *_p_QuantLib__BWPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BWPCurrency *) x));
}
static void *_p_QuantLib__BYRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::BYRCurrency *) x));
}
static void *_p_QuantLib__CADCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CADCurrency *) x));
}
static void *_p_QuantLib__CHFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CHFCurrency *) x));
}
static void *_p_QuantLib__CLFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CLFCurrency *) x));
}
static void *_p_QuantLib__CLPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CLPCurrency *) x));
}
static void *_p_QuantLib__CNHCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CNHCurrency *) x));
}
static void *_p_QuantLib__CNYCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CNYCurrency *) x));
}
static void *_p_QuantLib__COPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::COPCurrency *) x));
}
static void *_p_QuantLib__COUCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::COUCurrency *) x));
}
static void *_p_QuantLib__CYPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CYPCurrency *) x));
}
static void *_p_QuantLib__CZKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::CZKCurrency *) x));
}
static void *_p_QuantLib__DASHCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::DASHCurrency *) x));
}
static void *_p_QuantLib__DEMCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::DEMCurrency *) x));
}
static void *_p_QuantLib__DKKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::DKKCurrency *) x));
}
static void *_p_QuantLib__EEKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::EEKCurrency *) x));
}
static void *_p_QuantLib__EGPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::EGPCurrency *) x));
}
static void *_p_QuantLib__ESPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ESPCurrency *) x));
}
static void *_p_QuantLib__ETBCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ETBCurrency *) x));
}
static void *_p_QuantLib__ETCCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ETCCurrency *) x));
}
static void *_p_QuantLib__ETHCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ETHCurrency *) x));
}
static void *_p_QuantLib__EURCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::EURCurrency *) x));
}
static void *_p_QuantLib__FIMCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::FIMCurrency *) x));
}
static void *_p_QuantLib__FRFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::FRFCurrency *) x));
}
static void *_p_QuantLib__GBPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::GBPCurrency *) x));
}
static void *_p_QuantLib__GELCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::GELCurrency *) x));
}
static void *_p_QuantLib__GHSCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::GHSCurrency *) x));
}
static void *_p_QuantLib__GRDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::GRDCurrency *) x));
}
static void *_p_QuantLib__HKDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::HKDCurrency *) x));
}
static void *_p_QuantLib__HRKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::HRKCurrency *) x));
}
static void *_p_QuantLib__HUFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::HUFCurrency *) x));
}
static void *_p_QuantLib__IDRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::IDRCurrency *) x));
}
static void *_p_QuantLib__IEPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::IEPCurrency *) x));
}
static void *_p_QuantLib__ILSCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ILSCurrency *) x));
}
static void *_p_QuantLib__INRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::INRCurrency *) x));
}
static void *_p_QuantLib__IQDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::IQDCurrency *) x));
}
static void *_p_QuantLib__IRRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::IRRCurrency *) x));
}
static void *_p_QuantLib__ISKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ISKCurrency *) x));
}
static void *_p_QuantLib__ITLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ITLCurrency *) x));
}
static void *_p_QuantLib__JODCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::JODCurrency *) x));
}
static void *_p_QuantLib__JPYCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::JPYCurrency *) x));
}
static void *_p_QuantLib__KESCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::KESCurrency *) x));
}
static void *_p_QuantLib__KRWCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::KRWCurrency *) x));
}
static void *_p_QuantLib__KWDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::KWDCurrency *) x));
}
static void *_p_QuantLib__KZTCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::KZTCurrency *) x));
}
static void *_p_QuantLib__LKRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::LKRCurrency *) x));
}
static void *_p_QuantLib__LTCCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::LTCCurrency *) x));
}
static void *_p_QuantLib__LTLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::LTLCurrency *) x));
}
static void *_p_QuantLib__LUFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::LUFCurrency *) x));
}
static void *_p_QuantLib__LVLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::LVLCurrency *) x));
}
static void *_p_QuantLib__MADCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MADCurrency *) x));
}
static void *_p_QuantLib__MTLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MTLCurrency *) x));
}
static void *_p_QuantLib__MURCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MURCurrency *) x));
}
static void *_p_QuantLib__MXNCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MXNCurrency *) x));
}
static void *_p_QuantLib__MXVCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MXVCurrency *) x));
}
static void *_p_QuantLib__MYRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::MYRCurrency *) x));
}
static void *_p_QuantLib__NGNCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::NGNCurrency *) x));
}
static void *_p_QuantLib__NLGCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::NLGCurrency *) x));
}
static void *_p_QuantLib__NOKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::NOKCurrency *) x));
}
static void *_p_QuantLib__NPRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::NPRCurrency *) x));
}
static void *_p_QuantLib__NZDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::NZDCurrency *) x));
}
static void *_p_QuantLib__OMRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::OMRCurrency *) x));
}
static void *_p_QuantLib__PEHCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PEHCurrency *) x));
}
static void *_p_QuantLib__PEICurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PEICurrency *) x));
}
static void *_p_QuantLib__PENCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PENCurrency *) x));
}
static void *_p_QuantLib__PHPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PHPCurrency *) x));
}
static void *_p_QuantLib__PKRCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PKRCurrency *) x));
}
static void *_p_QuantLib__PLNCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PLNCurrency *) x));
}
static void *_p_QuantLib__PTECurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::PTECurrency *) x));
}
static void *_p_QuantLib__QARCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::QARCurrency *) x));
}
static void *_p_QuantLib__ROLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ROLCurrency *) x));
}
static void *_p_QuantLib__RONCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::RONCurrency *) x));
}
static void *_p_QuantLib__RSDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::RSDCurrency *) x));
}
static void *_p_QuantLib__RUBCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::RUBCurrency *) x));
}
static void *_p_QuantLib__SARCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::SARCurrency *) x));
}
static void *_p_QuantLib__SEKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::SEKCurrency *) x));
}
static void *_p_QuantLib__SGDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::SGDCurrency *) x));
}
static void *_p_QuantLib__SITCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::SITCurrency *) x));
}
static void *_p_QuantLib__SKKCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::SKKCurrency *) x));
}
static void *_p_QuantLib__THBCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::THBCurrency *) x));
}
static void *_p_QuantLib__TNDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::TNDCurrency *) x));
}
static void *_p_QuantLib__TRLCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::TRLCurrency *) x));
}
static void *_p_QuantLib__TRYCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::TRYCurrency *) x));
}
static void *_p_QuantLib__TTDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::TTDCurrency *) x));
}
static void *_p_QuantLib__TWDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::TWDCurrency *) x));
}
static void *_p_QuantLib__UAHCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::UAHCurrency *) x));
}
static void *_p_QuantLib__UGXCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::UGXCurrency *) x));
}
static void *_p_QuantLib__USDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::USDCurrency *) x));
}
static void *_p_QuantLib__UYUCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::UYUCurrency *) x));
}
static void *_p_QuantLib__VEBCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::VEBCurrency *) x));
}
static void *_p_QuantLib__VNDCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::VNDCurrency *) x));
}
static void *_p_QuantLib__XOFCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::XOFCurrency *) x));
}
static void *_p_QuantLib__XRPCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::XRPCurrency *) x));
}
static void *_p_QuantLib__ZARCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ZARCurrency *) x));
}
static void *_p_QuantLib__ZECCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ZECCurrency *) x));
}
static void *_p_QuantLib__ZMWCurrencyTo_p_Currency(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Currency *)  ((QuantLib::ZMWCurrency *) x));
}
static void *_p_LMMCurveStateTo_p_CurveState(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((CurveState *)  ((LMMCurveState *) x));
}
static void *_p_CADLiborONTo_p_DailyTenorLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DailyTenorLibor *)  ((CADLiborON *) x));
}
static void *_p_GBPLiborONTo_p_DailyTenorLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DailyTenorLibor *)  ((GBPLiborON *) x));
}
static void *_p_USDLiborONTo_p_DailyTenorLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DailyTenorLibor *)  ((USDLiborON *) x));
}
static void *_p_QuantLib__Actual360To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual360 *) x));
}
static void *_p_QuantLib__Actual364To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual364 *) x));
}
static void *_p_QuantLib__Actual36525To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual36525 *) x));
}
static void *_p_QuantLib__Actual365FixedTo_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual365Fixed *) x));
}
static void *_p_QuantLib__Actual366To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Actual366 *) x));
}
static void *_p_QuantLib__ActualActualTo_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::ActualActual *) x));
}
static void *_p_QuantLib__Business252To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Business252 *) x));
}
static void *_p_QuantLib__OneDayCounterTo_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::OneDayCounter *) x));
}
static void *_p_QuantLib__SimpleDayCounterTo_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::SimpleDayCounter *) x));
}
static void *_p_QuantLib__Thirty360To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Thirty360 *) x));
}
static void *_p_QuantLib__Thirty365To_p_DayCounter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DayCounter *)  ((QuantLib::Thirty365 *) x));
}
static void *_p_DirichletBCTo_p_DefaultBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultBoundaryCondition *)  ((DirichletBC *) x));
}
static void *_p_NeumannBCTo_p_DefaultBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultBoundaryCondition *)  ((NeumannBC *) x));
}
static void *_p_SpreadCdsHelperTo_p_DefaultProbabilityHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityHelper *)  ((SpreadCdsHelper *) x));
}
static void *_p_UpfrontCdsHelperTo_p_DefaultProbabilityHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityHelper *)  ((UpfrontCdsHelper *) x));
}
static void *_p_FlatHazardRateTo_p_DefaultProbabilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityTermStructure *)  ((FlatHazardRate *) x));
}
static void *_p_InterpolatedDefaultDensityCurveT_Linear_tTo_p_DefaultProbabilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityTermStructure *)  ((InterpolatedDefaultDensityCurve< Linear > *) x));
}
static void *_p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_DefaultProbabilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityTermStructure *)  ((InterpolatedHazardRateCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_DefaultProbabilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityTermStructure *)  ((InterpolatedSurvivalProbabilityCurve< Linear > *) x));
}
static void *_p_PiecewiseFlatHazardRateTo_p_DefaultProbabilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DefaultProbabilityTermStructure *)  ((PiecewiseFlatHazardRate *) x));
}
static void *_p_FixedDividendTo_p_Dividend(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Dividend *)  ((FixedDividend *) x));
}
static void *_p_FractionalDividendTo_p_Dividend(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Dividend *)  ((FractionalDividend *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_DoubleBarrierOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((DoubleBarrierOption *)  ((QuantoDoubleBarrierOption *) x));
}
static void *_p_EURLibor10MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor10M *) x));
}
static void *_p_EURLibor11MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor11M *) x));
}
static void *_p_EURLibor1MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor1M *) x));
}
static void *_p_EURLibor1YTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor1Y *) x));
}
static void *_p_EURLibor2MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor2M *) x));
}
static void *_p_EURLibor2WTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor2W *) x));
}
static void *_p_EURLibor3MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor3M *) x));
}
static void *_p_EURLibor4MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor4M *) x));
}
static void *_p_EURLibor5MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor5M *) x));
}
static void *_p_EURLibor6MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor6M *) x));
}
static void *_p_EURLibor7MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor7M *) x));
}
static void *_p_EURLibor8MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor8M *) x));
}
static void *_p_EURLibor9MTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLibor9M *) x));
}
static void *_p_EURLiborSWTo_p_EURLibor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EURLibor *)  ((EURLiborSW *) x));
}
static void *_p_EquityQuantoCashFlowPricerTo_p_EquityCashFlowPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((EquityCashFlowPricer *)  ((EquityQuantoCashFlowPricer *) x));
}
static void *_p_Euribor10MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor10M *) x));
}
static void *_p_Euribor11MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor11M *) x));
}
static void *_p_Euribor1MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor1M *) x));
}
static void *_p_Euribor1YTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor1Y *) x));
}
static void *_p_Euribor2MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor2M *) x));
}
static void *_p_Euribor2WTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor2W *) x));
}
static void *_p_Euribor3MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor3M *) x));
}
static void *_p_Euribor3WTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor3W *) x));
}
static void *_p_Euribor4MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor4M *) x));
}
static void *_p_Euribor5MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor5M *) x));
}
static void *_p_Euribor6MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor6M *) x));
}
static void *_p_Euribor7MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor7M *) x));
}
static void *_p_Euribor8MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor8M *) x));
}
static void *_p_Euribor9MTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((Euribor9M *) x));
}
static void *_p_EuriborSWTo_p_Euribor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor *)  ((EuriborSW *) x));
}
static void *_p_Euribor365_10MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_10M *) x));
}
static void *_p_Euribor365_11MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_11M *) x));
}
static void *_p_Euribor365_1MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_1M *) x));
}
static void *_p_Euribor365_1YTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_1Y *) x));
}
static void *_p_Euribor365_2MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_2M *) x));
}
static void *_p_Euribor365_2WTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_2W *) x));
}
static void *_p_Euribor365_3MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_3M *) x));
}
static void *_p_Euribor365_3WTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_3W *) x));
}
static void *_p_Euribor365_4MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_4M *) x));
}
static void *_p_Euribor365_5MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_5M *) x));
}
static void *_p_Euribor365_6MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_6M *) x));
}
static void *_p_Euribor365_7MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_7M *) x));
}
static void *_p_Euribor365_8MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_8M *) x));
}
static void *_p_Euribor365_9MTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_9M *) x));
}
static void *_p_Euribor365_SWTo_p_Euribor365(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Euribor365 *)  ((Euribor365_SW *) x));
}
static void *_p_AmericanExerciseTo_p_Exercise(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Exercise *)  ((AmericanExercise *) x));
}
static void *_p_BermudanExerciseTo_p_Exercise(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Exercise *)  ((BermudanExercise *) x));
}
static void *_p_EuropeanExerciseTo_p_Exercise(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Exercise *)  ((EuropeanExercise *) x));
}
static void *_p_RebatedExerciseTo_p_Exercise(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Exercise *)  ((RebatedExercise *) x));
}
static void *_p_SwingExerciseTo_p_Exercise(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Exercise *)  ((SwingExercise *) x));
}
static void *_p_Concentrating1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Concentrating1dMesher *) x));
}
static void *_p_ExponentialJump1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((ExponentialJump1dMesher *) x));
}
static void *_p_FdmBlackScholesMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmBlackScholesMesher *) x));
}
static void *_p_FdmCEV1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmCEV1dMesher *) x));
}
static void *_p_FdmHestonLocalVolatilityVarianceMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmHestonLocalVolatilityVarianceMesher *) x));
}
static void *_p_FdmHestonVarianceMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmHestonVarianceMesher *) x));
}
static void *_p_FdmSimpleProcess1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((FdmSimpleProcess1dMesher *) x));
}
static void *_p_Glued1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Glued1dMesher *) x));
}
static void *_p_Predefined1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Predefined1dMesher *) x));
}
static void *_p_Uniform1dMesherTo_p_Fdm1dMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Fdm1dMesher *)  ((Uniform1dMesher *) x));
}
static void *_p_FdmDirichletBoundaryTo_p_FdmBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmBoundaryCondition *)  ((FdmDirichletBoundary *) x));
}
static void *_p_FdmDiscountDirichletBoundaryTo_p_FdmBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmBoundaryCondition *)  ((FdmDiscountDirichletBoundary *) x));
}
static void *_p_FdmTimeDepDirichletBoundaryTo_p_FdmBoundaryCondition(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmBoundaryCondition *)  ((FdmTimeDepDirichletBoundary *) x));
}
static void *_p_FdmLogInnerValueTo_p_FdmCellAveragingInnerValue(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmCellAveragingInnerValue *)  ((FdmLogInnerValue *) x));
}
static void *_p_FdmAffineModelSwapInnerValueT_G2_tTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmAffineModelSwapInnerValue< G2 > *) x));
}
static void *_p_FdmAffineModelSwapInnerValueT_HullWhite_tTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmAffineModelSwapInnerValue< HullWhite > *) x));
}
static void *_p_FdmCellAveragingInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmCellAveragingInnerValue *) x));
}
static void *_p_FdmInnerValueCalculatorProxyTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmInnerValueCalculatorProxy *) x));
}
static void *_p_FdmLogBasketInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmLogBasketInnerValue *) x));
}
static void *_p_FdmLogInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *) (FdmCellAveragingInnerValue *) ((FdmLogInnerValue *) x));
}
static void *_p_FdmZeroInnerValueTo_p_FdmInnerValueCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmInnerValueCalculator *)  ((FdmZeroInnerValue *) x));
}
static void *_p_Fdm2dBlackScholesOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((Fdm2dBlackScholesOp *) x));
}
static void *_p_FdmBatesOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmBatesOp *) x));
}
static void *_p_FdmBlackScholesFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmBlackScholesFwdOp *) x));
}
static void *_p_FdmBlackScholesOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmBlackScholesOp *) x));
}
static void *_p_FdmCEVOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmCEVOp *) x));
}
static void *_p_FdmDupire1dOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmDupire1dOp *) x));
}
static void *_p_FdmG2OpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmG2Op *) x));
}
static void *_p_FdmHestonFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHestonFwdOp *) x));
}
static void *_p_FdmHestonHullWhiteOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHestonHullWhiteOp *) x));
}
static void *_p_FdmHestonOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHestonOp *) x));
}
static void *_p_FdmHullWhiteOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmHullWhiteOp *) x));
}
static void *_p_FdmLinearOpCompositeTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((FdmLinearOpComposite *) x));
}
static void *_p_FdmLinearOpCompositeProxyTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmLinearOpCompositeProxy *) x));
}
static void *_p_FdmLocalVolFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmLocalVolFwdOp *) x));
}
static void *_p_FdmOrnsteinUhlenbeckOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmOrnsteinUhlenbeckOp *) x));
}
static void *_p_FdmSabrOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmSabrOp *) x));
}
static void *_p_FdmSquareRootFwdOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmSquareRootFwdOp *) x));
}
static void *_p_FdmZabrOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (FdmLinearOpComposite *) ((FdmZabrOp *) x));
}
static void *_p_FirstDerivativeOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (TripleBandLinearOp *) ((FirstDerivativeOp *) x));
}
static void *_p_NinePointLinearOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((NinePointLinearOp *) x));
}
static void *_p_NthOrderDerivativeOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((NthOrderDerivativeOp *) x));
}
static void *_p_SecondDerivativeOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (TripleBandLinearOp *) ((SecondDerivativeOp *) x));
}
static void *_p_SecondOrderMixedDerivativeOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *) (NinePointLinearOp *) ((SecondOrderMixedDerivativeOp *) x));
}
static void *_p_TripleBandLinearOpTo_p_FdmLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOp *)  ((TripleBandLinearOp *) x));
}
static void *_p_Fdm2dBlackScholesOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((Fdm2dBlackScholesOp *) x));
}
static void *_p_FdmBatesOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmBatesOp *) x));
}
static void *_p_FdmBlackScholesFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmBlackScholesFwdOp *) x));
}
static void *_p_FdmBlackScholesOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmBlackScholesOp *) x));
}
static void *_p_FdmCEVOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmCEVOp *) x));
}
static void *_p_FdmDupire1dOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmDupire1dOp *) x));
}
static void *_p_FdmG2OpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmG2Op *) x));
}
static void *_p_FdmHestonFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHestonFwdOp *) x));
}
static void *_p_FdmHestonHullWhiteOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHestonHullWhiteOp *) x));
}
static void *_p_FdmHestonOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHestonOp *) x));
}
static void *_p_FdmHullWhiteOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmHullWhiteOp *) x));
}
static void *_p_FdmLinearOpCompositeProxyTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmLinearOpCompositeProxy *) x));
}
static void *_p_FdmLocalVolFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmLocalVolFwdOp *) x));
}
static void *_p_FdmOrnsteinUhlenbeckOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmOrnsteinUhlenbeckOp *) x));
}
static void *_p_FdmSabrOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmSabrOp *) x));
}
static void *_p_FdmSquareRootFwdOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmSquareRootFwdOp *) x));
}
static void *_p_FdmZabrOpTo_p_FdmLinearOpComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmLinearOpComposite *)  ((FdmZabrOp *) x));
}
static void *_p_FdmMesherCompositeTo_p_FdmMesher(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FdmMesher *)  ((FdmMesherComposite *) x));
}
static void *_p_CubicBSplinesFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((CubicBSplinesFitting *) x));
}
static void *_p_ExponentialSplinesFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((ExponentialSplinesFitting *) x));
}
static void *_p_NelsonSiegelFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((NelsonSiegelFitting *) x));
}
static void *_p_SimplePolynomialFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((SimplePolynomialFitting *) x));
}
static void *_p_SpreadFittingMethodTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((SpreadFittingMethod *) x));
}
static void *_p_SvenssonFittingTo_p_FittingMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FittingMethod *)  ((SvenssonFitting *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *) (CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *) (CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((CappedFlooredCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *) (CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_CmsCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((CmsCoupon *) x));
}
static void *_p_CmsSpreadCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((CmsSpreadCoupon *) x));
}
static void *_p_IborCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((IborCoupon *) x));
}
static void *_p_OvernightIndexedCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((OvernightIndexedCoupon *) x));
}
static void *_p_SubPeriodsCouponTo_p_FloatingRateCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCoupon *)  ((SubPeriodsCoupon *) x));
}
static void *_p_AnalyticHaganPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsCouponPricer *) ((AnalyticHaganPricer *) x));
}
static void *_p_AveragingRatePricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (SubPeriodsPricer *) ((AveragingRatePricer *) x));
}
static void *_p_BlackIborCouponPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (IborCouponPricer *) ((BlackIborCouponPricer *) x));
}
static void *_p_CmsCouponPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *)  ((CmsCouponPricer *) x));
}
static void *_p_CmsSpreadCouponPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *)  ((CmsSpreadCouponPricer *) x));
}
static void *_p_CompoundingRatePricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (SubPeriodsPricer *) ((CompoundingRatePricer *) x));
}
static void *_p_IborCouponPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *)  ((IborCouponPricer *) x));
}
static void *_p_LinearTsrPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsCouponPricer *) ((LinearTsrPricer *) x));
}
static void *_p_LognormalCmsSpreadPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsSpreadCouponPricer *) ((LognormalCmsSpreadPricer *) x));
}
static void *_p_NumericHaganPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *) (CmsCouponPricer *) ((NumericHaganPricer *) x));
}
static void *_p_SubPeriodsPricerTo_p_FloatingRateCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FloatingRateCouponPricer *)  ((SubPeriodsPricer *) x));
}
static void *_p_BondForwardTo_p_Forward(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Forward *)  ((BondForward *) x));
}
static void *_p_FixedRateBondForwardTo_p_Forward(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Forward *) (BondForward *) ((FixedRateBondForward *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_ForwardVanillaOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ForwardVanillaOption *)  ((QuantoForwardVanillaOption *) x));
}
static void *_p_GsrTo_p_Gaussian1dModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Gaussian1dModel *)  ((Gsr *) x));
}
static void *_p_MarkovFunctionalTo_p_Gaussian1dModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Gaussian1dModel *)  ((MarkovFunctional *) x));
}
static void *_p_GaussChebyshev2ndIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussChebyshev2ndIntegration *) x));
}
static void *_p_GaussChebyshevIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussChebyshevIntegration *) x));
}
static void *_p_GaussGegenbauerIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussGegenbauerIntegration *) x));
}
static void *_p_GaussHermiteIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussHermiteIntegration *) x));
}
static void *_p_GaussHyperbolicIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussHyperbolicIntegration *) x));
}
static void *_p_GaussJacobiIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussJacobiIntegration *) x));
}
static void *_p_GaussLaguerreIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussLaguerreIntegration *) x));
}
static void *_p_GaussLegendreIntegrationTo_p_GaussianQuadrature(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GaussianQuadrature *)  ((GaussLegendreIntegration *) x));
}
static void *_p_BlackProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((BlackProcess *) x));
}
static void *_p_BlackScholesMertonProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((BlackScholesMertonProcess *) x));
}
static void *_p_BlackScholesProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((BlackScholesProcess *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_GeneralizedBlackScholesProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((GeneralizedBlackScholesProcess *)  ((GarmanKohlagenProcess *) x));
}
static void *_p_RelinkableHandleT_BlackVolTermStructure_tTo_p_HandleT_BlackVolTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< BlackVolTermStructure > *)  ((RelinkableHandle< BlackVolTermStructure > *) x));
}
static void *_p_RelinkableHandleT_CalibratedModel_tTo_p_HandleT_CalibratedModel_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< CalibratedModel > *)  ((RelinkableHandle< CalibratedModel > *) x));
}
static void *_p_RelinkableHandleT_CapFloorTermVolatilityStructure_tTo_p_HandleT_CapFloorTermVolatilityStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< CapFloorTermVolatilityStructure > *)  ((RelinkableHandle< CapFloorTermVolatilityStructure > *) x));
}
static void *_p_RelinkableHandleT_DefaultProbabilityTermStructure_tTo_p_HandleT_DefaultProbabilityTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< DefaultProbabilityTermStructure > *)  ((RelinkableHandle< DefaultProbabilityTermStructure > *) x));
}
static void *_p_RelinkableHandleT_DeltaVolQuote_tTo_p_HandleT_DeltaVolQuote_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< DeltaVolQuote > *)  ((RelinkableHandle< DeltaVolQuote > *) x));
}
static void *_p_RelinkableHandleT_LocalVolTermStructure_tTo_p_HandleT_LocalVolTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< LocalVolTermStructure > *)  ((RelinkableHandle< LocalVolTermStructure > *) x));
}
static void *_p_RelinkableHandleT_OptionletVolatilityStructure_tTo_p_HandleT_OptionletVolatilityStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< OptionletVolatilityStructure > *)  ((RelinkableHandle< OptionletVolatilityStructure > *) x));
}
static void *_p_RelinkableHandleT_Quote_tTo_p_HandleT_Quote_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< Quote > *)  ((RelinkableHandle< Quote > *) x));
}
static void *_p_RelinkableHandleT_ShortRateModel_tTo_p_HandleT_ShortRateModel_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< ShortRateModel > *)  ((RelinkableHandle< ShortRateModel > *) x));
}
static void *_p_RelinkableHandleT_SwaptionVolatilityStructure_tTo_p_HandleT_SwaptionVolatilityStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< SwaptionVolatilityStructure > *)  ((RelinkableHandle< SwaptionVolatilityStructure > *) x));
}
static void *_p_RelinkableHandleT_YieldTermStructure_tTo_p_HandleT_YieldTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< YieldTermStructure > *)  ((RelinkableHandle< YieldTermStructure > *) x));
}
static void *_p_RelinkableHandleT_YoYInflationTermStructure_tTo_p_HandleT_YoYInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< YoYInflationTermStructure > *)  ((RelinkableHandle< YoYInflationTermStructure > *) x));
}
static void *_p_RelinkableHandleT_YoYOptionletVolatilitySurface_tTo_p_HandleT_YoYOptionletVolatilitySurface_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< YoYOptionletVolatilitySurface > *)  ((RelinkableHandle< YoYOptionletVolatilitySurface > *) x));
}
static void *_p_RelinkableHandleT_ZeroInflationTermStructure_tTo_p_HandleT_ZeroInflationTermStructure_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Handle< ZeroInflationTermStructure > *)  ((RelinkableHandle< ZeroInflationTermStructure > *) x));
}
static void *_p_BatesModelTo_p_HestonModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((HestonModel *)  ((BatesModel *) x));
}
static void *_p_BatesProcessTo_p_HestonProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((HestonProcess *)  ((BatesProcess *) x));
}
static void *_p_BlackIborCouponPricerTo_p_IborCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborCouponPricer *)  ((BlackIborCouponPricer *) x));
}
static void *_p_AUDLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((AUDLibor *) x));
}
static void *_p_AoniaTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Aonia *) x));
}
static void *_p_BbswTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Bbsw *) x));
}
static void *_p_Bbsw1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Bbsw2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw2M *) x));
}
static void *_p_Bbsw3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw3M *) x));
}
static void *_p_Bbsw4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw4M *) x));
}
static void *_p_Bbsw5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw5M *) x));
}
static void *_p_Bbsw6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bbsw *) ((Bbsw6M *) x));
}
static void *_p_BiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Bibor *) x));
}
static void *_p_Bibor1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor1M *) x));
}
static void *_p_Bibor1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor1Y *) x));
}
static void *_p_Bibor2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor2M *) x));
}
static void *_p_Bibor3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor3M *) x));
}
static void *_p_Bibor6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor6M *) x));
}
static void *_p_Bibor9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((Bibor9M *) x));
}
static void *_p_BiborSWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bibor *) ((BiborSW *) x));
}
static void *_p_BkbmTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Bkbm *) x));
}
static void *_p_Bkbm1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm1M *) x));
}
static void *_p_Bkbm2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bkbm3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm3M *) x));
}
static void *_p_Bkbm4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm4M *) x));
}
static void *_p_Bkbm5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm5M *) x));
}
static void *_p_Bkbm6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Bkbm *) ((Bkbm6M *) x));
}
static void *_p_CADLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((CADLibor *) x));
}
static void *_p_CADLiborONTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_CHFLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((CHFLibor *) x));
}
static void *_p_CdorTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Cdor *) x));
}
static void *_p_CorraTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Corra *) x));
}
static void *_p_DKKLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((DKKLibor *) x));
}
static void *_p_DailyTenorLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((DailyTenorLibor *) x));
}
static void *_p_DestrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Destr *) x));
}
static void *_p_EURLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((EURLibor *) x));
}
static void *_p_EURLibor10MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor10M *) x));
}
static void *_p_EURLibor11MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor11M *) x));
}
static void *_p_EURLibor1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor1M *) x));
}
static void *_p_EURLibor1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_EURLibor2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor2M *) x));
}
static void *_p_EURLibor2WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor2W *) x));
}
static void *_p_EURLibor3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor3M *) x));
}
static void *_p_EURLibor4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor4M *) x));
}
static void *_p_EURLibor5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor5M *) x));
}
static void *_p_EURLibor6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor6M *) x));
}
static void *_p_EURLibor7MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor7M *) x));
}
static void *_p_EURLibor8MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor8M *) x));
}
static void *_p_EURLibor9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLibor9M *) x));
}
static void *_p_EURLiborSWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EoniaTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Eonia *) x));
}
static void *_p_EstrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Estr *) x));
}
static void *_p_EuriborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Euribor *) x));
}
static void *_p_Euribor10MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor10M *) x));
}
static void *_p_Euribor11MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor11M *) x));
}
static void *_p_Euribor1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor1M *) x));
}
static void *_p_Euribor1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor1Y *) x));
}
static void *_p_Euribor2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor2M *) x));
}
static void *_p_Euribor2WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor2W *) x));
}
static void *_p_Euribor365To_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Euribor365 *) x));
}
static void *_p_Euribor365_10MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_10M *) x));
}
static void *_p_Euribor365_11MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_11M *) x));
}
static void *_p_Euribor365_1MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_1M *) x));
}
static void *_p_Euribor365_1YTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_1Y *) x));
}
static void *_p_Euribor365_2MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_Euribor365_2WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_2W *) x));
}
static void *_p_Euribor365_3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_3M *) x));
}
static void *_p_Euribor365_3WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_3W *) x));
}
static void *_p_Euribor365_4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_4M *) x));
}
static void *_p_Euribor365_5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_5M *) x));
}
static void *_p_Euribor365_6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_6M *) x));
}
static void *_p_Euribor365_7MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_7M *) x));
}
static void *_p_Euribor365_8MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_8M *) x));
}
static void *_p_Euribor365_9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_9M *) x));
}
static void *_p_Euribor365_SWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor365 *) ((Euribor365_SW *) x));
}
static void *_p_Euribor3MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor3M *) x));
}
static void *_p_Euribor3WTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor3W *) x));
}
static void *_p_Euribor4MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor4M *) x));
}
static void *_p_Euribor5MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor5M *) x));
}
static void *_p_Euribor6MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor6M *) x));
}
static void *_p_Euribor7MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor7M *) x));
}
static void *_p_Euribor8MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor8M *) x));
}
static void *_p_Euribor9MTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((Euribor9M *) x));
}
static void *_p_EuriborSWTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (Euribor *) ((EuriborSW *) x));
}
static void *_p_FedFundsTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((FedFunds *) x));
}
static void *_p_GBPLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((GBPLibor *) x));
}
static void *_p_GBPLiborONTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_JPYLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((JPYLibor *) x));
}
static void *_p_JibarTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Jibar *) x));
}
static void *_p_LiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Libor *) x));
}
static void *_p_MosprimeTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Mosprime *) x));
}
static void *_p_NZDLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((NZDLibor *) x));
}
static void *_p_NzocrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Nzocr *) x));
}
static void *_p_OvernightIndexTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((OvernightIndex *) x));
}
static void *_p_PriborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Pribor *) x));
}
static void *_p_RoborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Robor *) x));
}
static void *_p_SEKLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((SEKLibor *) x));
}
static void *_p_ShiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Shibor *) x));
}
static void *_p_SofrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Sofr *) x));
}
static void *_p_SoniaTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Sonia *) x));
}
static void *_p_SwestrTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (OvernightIndex *) ((Swestr *) x));
}
static void *_p_THBFIXTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((THBFIX *) x));
}
static void *_p_TRLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((TRLibor *) x));
}
static void *_p_TiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Tibor *) x));
}
static void *_p_USDLiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((USDLibor *) x));
}
static void *_p_USDLiborONTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *) (DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_WiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Wibor *) x));
}
static void *_p_ZiborTo_p_IborIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IborIndex *)  ((Zibor *) x));
}
static void *_p_AUCPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((AUCPI *) x));
}
static void *_p_AUDLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((AUDLibor *) x));
}
static void *_p_AoniaTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Aonia *) x));
}
static void *_p_BbswTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Bbsw *) x));
}
static void *_p_Bbsw1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Bbsw2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw2M *) x));
}
static void *_p_Bbsw3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw3M *) x));
}
static void *_p_Bbsw4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw4M *) x));
}
static void *_p_Bbsw5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw5M *) x));
}
static void *_p_Bbsw6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw6M *) x));
}
static void *_p_BiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Bibor *) x));
}
static void *_p_Bibor1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1M *) x));
}
static void *_p_Bibor1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1Y *) x));
}
static void *_p_Bibor2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor2M *) x));
}
static void *_p_Bibor3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor3M *) x));
}
static void *_p_Bibor6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor6M *) x));
}
static void *_p_Bibor9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor9M *) x));
}
static void *_p_BiborSWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bibor *) ((BiborSW *) x));
}
static void *_p_BkbmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Bkbm *) x));
}
static void *_p_Bkbm1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm1M *) x));
}
static void *_p_Bkbm2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bkbm3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm3M *) x));
}
static void *_p_Bkbm4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm4M *) x));
}
static void *_p_Bkbm5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm5M *) x));
}
static void *_p_Bkbm6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm6M *) x));
}
static void *_p_CADLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((CADLibor *) x));
}
static void *_p_CADLiborONTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_CHFLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((CHFLibor *) x));
}
static void *_p_CdorTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Cdor *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_CorraTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Corra *) x));
}
static void *_p_DKKLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((DKKLibor *) x));
}
static void *_p_DailyTenorLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((DailyTenorLibor *) x));
}
static void *_p_DestrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Destr *) x));
}
static void *_p_EUHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((EUHICP *) x));
}
static void *_p_EUHICPXTTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((EUHICPXT *) x));
}
static void *_p_EURLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((EURLibor *) x));
}
static void *_p_EURLibor10MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor10M *) x));
}
static void *_p_EURLibor11MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor11M *) x));
}
static void *_p_EURLibor1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1M *) x));
}
static void *_p_EURLibor1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_EURLibor2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2M *) x));
}
static void *_p_EURLibor2WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2W *) x));
}
static void *_p_EURLibor3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor3M *) x));
}
static void *_p_EURLibor4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor4M *) x));
}
static void *_p_EURLibor5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor5M *) x));
}
static void *_p_EURLibor6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor6M *) x));
}
static void *_p_EURLibor7MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor7M *) x));
}
static void *_p_EURLibor8MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor8M *) x));
}
static void *_p_EURLibor9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor9M *) x));
}
static void *_p_EURLiborSWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EoniaTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Eonia *) x));
}
static void *_p_EquityIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *)  ((EquityIndex *) x));
}
static void *_p_EstrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Estr *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_EuriborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Euribor *) x));
}
static void *_p_Euribor10MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor10M *) x));
}
static void *_p_Euribor11MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor11M *) x));
}
static void *_p_Euribor1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1M *) x));
}
static void *_p_Euribor1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1Y *) x));
}
static void *_p_Euribor2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2M *) x));
}
static void *_p_Euribor2WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2W *) x));
}
static void *_p_Euribor365To_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Euribor365 *) x));
}
static void *_p_Euribor365_10MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_10M *) x));
}
static void *_p_Euribor365_11MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_11M *) x));
}
static void *_p_Euribor365_1MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_1M *) x));
}
static void *_p_Euribor365_1YTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_1Y *) x));
}
static void *_p_Euribor365_2MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_Euribor365_2WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_2W *) x));
}
static void *_p_Euribor365_3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_3M *) x));
}
static void *_p_Euribor365_3WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_3W *) x));
}
static void *_p_Euribor365_4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_4M *) x));
}
static void *_p_Euribor365_5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_5M *) x));
}
static void *_p_Euribor365_6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_6M *) x));
}
static void *_p_Euribor365_7MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_7M *) x));
}
static void *_p_Euribor365_8MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_8M *) x));
}
static void *_p_Euribor365_9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_9M *) x));
}
static void *_p_Euribor365_SWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_SW *) x));
}
static void *_p_Euribor3MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3M *) x));
}
static void *_p_Euribor3WTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3W *) x));
}
static void *_p_Euribor4MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor4M *) x));
}
static void *_p_Euribor5MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor5M *) x));
}
static void *_p_Euribor6MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor6M *) x));
}
static void *_p_Euribor7MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor7M *) x));
}
static void *_p_Euribor8MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor8M *) x));
}
static void *_p_Euribor9MTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor9M *) x));
}
static void *_p_EuriborSWTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(Euribor *) ((EuriborSW *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EuriborSwapIfrFix *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixB *) x));
}
static void *_p_FRHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((FRHICP *) x));
}
static void *_p_FedFundsTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((FedFunds *) x));
}
static void *_p_GBPLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((GBPLibor *) x));
}
static void *_p_GBPLiborONTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_IborIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *) ((IborIndex *) x));
}
static void *_p_InflationIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *)  ((InflationIndex *) x));
}
static void *_p_InterestRateIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *)  ((InterestRateIndex *) x));
}
static void *_p_JPYLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((JPYLibor *) x));
}
static void *_p_JibarTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Jibar *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_JpyLiborSwapIsdaFixPmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_LiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Libor *) x));
}
static void *_p_MosprimeTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Mosprime *) x));
}
static void *_p_NZDLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((NZDLibor *) x));
}
static void *_p_NzocrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Nzocr *) x));
}
static void *_p_OvernightIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((OvernightIndex *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((OvernightIndexedSwapIndex *) x));
}
static void *_p_PriborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Pribor *) x));
}
static void *_p_RoborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Robor *) x));
}
static void *_p_SEKLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((SEKLibor *) x));
}
static void *_p_ShiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Shibor *) x));
}
static void *_p_SofrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sofr *) x));
}
static void *_p_SoniaTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sonia *) x));
}
static void *_p_SwapIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *) ((SwapIndex *) x));
}
static void *_p_SwapSpreadIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *) ((SwapSpreadIndex *) x));
}
static void *_p_SwestrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Swestr *) x));
}
static void *_p_THBFIXTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((THBFIX *) x));
}
static void *_p_TRLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((TRLibor *) x));
}
static void *_p_TiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Tibor *) x));
}
static void *_p_UKHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((UKHICP *) x));
}
static void *_p_UKRPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((UKRPI *) x));
}
static void *_p_USCPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((USCPI *) x));
}
static void *_p_USDLiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((USDLibor *) x));
}
static void *_p_USDLiborONTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_WiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Wibor *) x));
}
static void *_p_YYEUHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYEUHICP *) x));
}
static void *_p_YYEUHICPXTTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYEUHICPXT *) x));
}
static void *_p_YYEUHICPrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYEUHICPr *) x));
}
static void *_p_YYFRHICPTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYFRHICP *) x));
}
static void *_p_YYFRHICPrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYFRHICPr *) x));
}
static void *_p_YYUKRPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUKRPI *) x));
}
static void *_p_YYUKRPIrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUKRPIr *) x));
}
static void *_p_YYUSCPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUSCPI *) x));
}
static void *_p_YYUSCPIrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYUSCPIr *) x));
}
static void *_p_YYZACPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYZACPI *) x));
}
static void *_p_YYZACPIrTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(YoYInflationIndex *) ((YYZACPIr *) x));
}
static void *_p_YoYInflationIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *) ((YoYInflationIndex *) x));
}
static void *_p_ZACPITo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *)(ZeroInflationIndex *) ((ZACPI *) x));
}
static void *_p_ZeroInflationIndexTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InflationIndex *) ((ZeroInflationIndex *) x));
}
static void *_p_ZiborTo_p_Index(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Index *) (InterestRateIndex *)(IborIndex *) ((Zibor *) x));
}
static void *_p_CPICashFlowTo_p_IndexedCashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IndexedCashFlow *)  ((CPICashFlow *) x));
}
static void *_p_EquityCashFlowTo_p_IndexedCashFlow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((IndexedCashFlow *)  ((EquityCashFlow *) x));
}
static void *_p_CPICouponTo_p_InflationCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationCoupon *)  ((CPICoupon *) x));
}
static void *_p_CappedFlooredYoYInflationCouponTo_p_InflationCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationCoupon *) (YoYInflationCoupon *) ((CappedFlooredYoYInflationCoupon *) x));
}
static void *_p_YoYInflationCouponTo_p_InflationCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationCoupon *)  ((YoYInflationCoupon *) x));
}
static void *_p_AUCPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((AUCPI *) x));
}
static void *_p_EUHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((EUHICP *) x));
}
static void *_p_EUHICPXTTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((EUHICPXT *) x));
}
static void *_p_FRHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((FRHICP *) x));
}
static void *_p_UKHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((UKHICP *) x));
}
static void *_p_UKRPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((UKRPI *) x));
}
static void *_p_USCPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((USCPI *) x));
}
static void *_p_YYEUHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYEUHICP *) x));
}
static void *_p_YYEUHICPXTTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYEUHICPXT *) x));
}
static void *_p_YYEUHICPrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYEUHICPr *) x));
}
static void *_p_YYFRHICPTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYFRHICP *) x));
}
static void *_p_YYFRHICPrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYFRHICPr *) x));
}
static void *_p_YYUKRPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUKRPI *) x));
}
static void *_p_YYUKRPIrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUKRPIr *) x));
}
static void *_p_YYUSCPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUSCPI *) x));
}
static void *_p_YYUSCPIrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYUSCPIr *) x));
}
static void *_p_YYZACPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYZACPI *) x));
}
static void *_p_YYZACPIrTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (YoYInflationIndex *) ((YYZACPIr *) x));
}
static void *_p_YoYInflationIndexTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *)  ((YoYInflationIndex *) x));
}
static void *_p_ZACPITo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *) (ZeroInflationIndex *) ((ZACPI *) x));
}
static void *_p_ZeroInflationIndexTo_p_InflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationIndex *)  ((ZeroInflationIndex *) x));
}
static void *_p_InterpolatedYoYInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (YoYInflationTermStructure *) ((InterpolatedYoYInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (ZeroInflationTermStructure *) ((InterpolatedZeroInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseYoYInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (YoYInflationTermStructure *) ((PiecewiseYoYInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseZeroInflationCurveT_Linear_tTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (ZeroInflationTermStructure *) ((PiecewiseZeroInflationCurve< Linear > *) x));
}
static void *_p_YoYCapFloorTermPriceSurfaceTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *)  ((YoYCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationCapFloorTermPriceSurfaceTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *) (YoYCapFloorTermPriceSurface *) ((YoYInflationCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationTermStructureTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *)  ((YoYInflationTermStructure *) x));
}
static void *_p_ZeroInflationTermStructureTo_p_InflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InflationTermStructure *)  ((ZeroInflationTermStructure *) x));
}
static void *_p_AmortizingCmsRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((AmortizingCmsRateBond *) x));
}
static void *_p_AmortizingFixedRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((AmortizingFixedRateBond *) x));
}
static void *_p_AmortizingFloatingRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((AmortizingFloatingRateBond *) x));
}
static void *_p_ArithmeticAverageOISTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((ArithmeticAverageOIS *) x));
}
static void *_p_AssetSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((AssetSwap *) x));
}
static void *_p_BarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_BasketOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_BondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Bond *) x));
}
static void *_p_BondForwardTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Forward *) ((BondForward *) x));
}
static void *_p_CPIBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((CPIBond *) x));
}
static void *_p_CPISwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((CPISwap *) x));
}
static void *_p_CallableBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((CallableBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *)(CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *)(CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_CapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (CapFloor *) ((Cap *) x));
}
static void *_p_CapFloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((CapFloor *) x));
}
static void *_p_CdsOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((CdsOption *) x));
}
static void *_p_CliquetOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((CliquetOption *) x));
}
static void *_p_CmsRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((CmsRateBond *) x));
}
static void *_p_CollarTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (CapFloor *) ((Collar *) x));
}
static void *_p_ComplexChooserOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ComplexChooserOption *) x));
}
static void *_p_CompositeInstrumentTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((CompositeInstrument *) x));
}
static void *_p_CompoundOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((CompoundOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_ContinuousFixedLookbackOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ContinuousFixedLookbackOption *) x));
}
static void *_p_ContinuousFloatingLookbackOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ContinuousFloatingLookbackOption *) x));
}
static void *_p_ContinuousPartialFixedLookbackOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(ContinuousFixedLookbackOption *) ((ContinuousPartialFixedLookbackOption *) x));
}
static void *_p_ContinuousPartialFloatingLookbackOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(ContinuousFloatingLookbackOption *) ((ContinuousPartialFloatingLookbackOption *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ConvertibleFixedCouponBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ConvertibleFloatingRateBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ConvertibleZeroCouponBond *) x));
}
static void *_p_CreditDefaultSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((CreditDefaultSwap *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((DividendVanillaOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_EquityTotalReturnSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((EquityTotalReturnSwap *) x));
}
static void *_p_EuropeanOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_EverestOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((EverestOption *) x));
}
static void *_p_FixedRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((FixedRateBond *) x));
}
static void *_p_FixedRateBondForwardTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Forward *)(BondForward *) ((FixedRateBondForward *) x));
}
static void *_p_FloatFloatSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((FloatFloatSwap *) x));
}
static void *_p_FloatFloatSwaptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((FloatFloatSwaption *) x));
}
static void *_p_FloatingRateBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((FloatingRateBond *) x));
}
static void *_p_FloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (CapFloor *) ((Floor *) x));
}
static void *_p_ForwardTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Forward *) x));
}
static void *_p_ForwardRateAgreementTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((ForwardRateAgreement *) x));
}
static void *_p_ForwardVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((ForwardVanillaOption *) x));
}
static void *_p_HimalayaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_MargrabeOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((MargrabeOption *) x));
}
static void *_p_MultiAssetOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((MultiAssetOption *) x));
}
static void *_p_NonstandardSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((NonstandardSwap *) x));
}
static void *_p_NonstandardSwaptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((NonstandardSwaption *) x));
}
static void *_p_OneAssetOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((OneAssetOption *) x));
}
static void *_p_OptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Option *) x));
}
static void *_p_OvernightIndexFutureTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((OvernightIndexFuture *) x));
}
static void *_p_OvernightIndexedSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((OvernightIndexedSwap *) x));
}
static void *_p_PartialTimeBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((PartialTimeBarrierOption *) x));
}
static void *_p_QuantoBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(BarrierOption *) ((QuantoBarrierOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *)(ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((QuantoVanillaOption *) x));
}
static void *_p_SimpleChooserOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((SimpleChooserOption *) x));
}
static void *_p_SpreadOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_StockTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Stock *) x));
}
static void *_p_SwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((Swap *) x));
}
static void *_p_SwaptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *) ((Swaption *) x));
}
static void *_p_VanillaOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((VanillaOption *) x));
}
static void *_p_VanillaSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((VanillaSwap *) x));
}
static void *_p_VanillaSwingOptionTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Option *)(OneAssetOption *) ((VanillaSwingOption *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((YearOnYearInflationSwap *) x));
}
static void *_p_YoYInflationCapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (YoYInflationCapFloor *) ((YoYInflationCap *) x));
}
static void *_p_YoYInflationCapFloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *)  ((YoYInflationCapFloor *) x));
}
static void *_p_YoYInflationCollarTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (YoYInflationCapFloor *) ((YoYInflationCollar *) x));
}
static void *_p_YoYInflationFloorTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (YoYInflationCapFloor *) ((YoYInflationFloor *) x));
}
static void *_p_ZeroCouponBondTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Bond *) ((ZeroCouponBond *) x));
}
static void *_p_ZeroCouponInflationSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((ZeroCouponInflationSwap *) x));
}
static void *_p_ZeroCouponSwapTo_p_Instrument(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Instrument *) (Swap *) ((ZeroCouponSwap *) x));
}
static void *_p_AUDLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((AUDLibor *) x));
}
static void *_p_AoniaTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Aonia *) x));
}
static void *_p_BbswTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Bbsw *) x));
}
static void *_p_Bbsw1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Bbsw2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw2M *) x));
}
static void *_p_Bbsw3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw3M *) x));
}
static void *_p_Bbsw4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw4M *) x));
}
static void *_p_Bbsw5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw5M *) x));
}
static void *_p_Bbsw6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bbsw *) ((Bbsw6M *) x));
}
static void *_p_BiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Bibor *) x));
}
static void *_p_Bibor1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor1M *) x));
}
static void *_p_Bibor1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor1Y *) x));
}
static void *_p_Bibor2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor2M *) x));
}
static void *_p_Bibor3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor3M *) x));
}
static void *_p_Bibor6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor6M *) x));
}
static void *_p_Bibor9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((Bibor9M *) x));
}
static void *_p_BiborSWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bibor *) ((BiborSW *) x));
}
static void *_p_BkbmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Bkbm *) x));
}
static void *_p_Bkbm1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm1M *) x));
}
static void *_p_Bkbm2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bkbm3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm3M *) x));
}
static void *_p_Bkbm4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm4M *) x));
}
static void *_p_Bkbm5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm5M *) x));
}
static void *_p_Bkbm6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Bkbm *) ((Bkbm6M *) x));
}
static void *_p_CADLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((CADLibor *) x));
}
static void *_p_CADLiborONTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_CHFLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((CHFLibor *) x));
}
static void *_p_CdorTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Cdor *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_CorraTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Corra *) x));
}
static void *_p_DKKLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((DKKLibor *) x));
}
static void *_p_DailyTenorLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((DailyTenorLibor *) x));
}
static void *_p_DestrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Destr *) x));
}
static void *_p_EURLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((EURLibor *) x));
}
static void *_p_EURLibor10MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor10M *) x));
}
static void *_p_EURLibor11MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor11M *) x));
}
static void *_p_EURLibor1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor1M *) x));
}
static void *_p_EURLibor1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_EURLibor2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor2M *) x));
}
static void *_p_EURLibor2WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor2W *) x));
}
static void *_p_EURLibor3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor3M *) x));
}
static void *_p_EURLibor4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor4M *) x));
}
static void *_p_EURLibor5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor5M *) x));
}
static void *_p_EURLibor6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor6M *) x));
}
static void *_p_EURLibor7MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor7M *) x));
}
static void *_p_EURLibor8MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor8M *) x));
}
static void *_p_EURLibor9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLibor9M *) x));
}
static void *_p_EURLiborSWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EoniaTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Eonia *) x));
}
static void *_p_EstrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Estr *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EurLiborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_EuriborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Euribor *) x));
}
static void *_p_Euribor10MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor10M *) x));
}
static void *_p_Euribor11MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor11M *) x));
}
static void *_p_Euribor1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor1M *) x));
}
static void *_p_Euribor1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor1Y *) x));
}
static void *_p_Euribor2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor2M *) x));
}
static void *_p_Euribor2WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor2W *) x));
}
static void *_p_Euribor365To_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Euribor365 *) x));
}
static void *_p_Euribor365_10MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_10M *) x));
}
static void *_p_Euribor365_11MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_11M *) x));
}
static void *_p_Euribor365_1MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_1M *) x));
}
static void *_p_Euribor365_1YTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_1Y *) x));
}
static void *_p_Euribor365_2MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_Euribor365_2WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_2W *) x));
}
static void *_p_Euribor365_3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_3M *) x));
}
static void *_p_Euribor365_3WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_3W *) x));
}
static void *_p_Euribor365_4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_4M *) x));
}
static void *_p_Euribor365_5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_5M *) x));
}
static void *_p_Euribor365_6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_6M *) x));
}
static void *_p_Euribor365_7MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_7M *) x));
}
static void *_p_Euribor365_8MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_8M *) x));
}
static void *_p_Euribor365_9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_9M *) x));
}
static void *_p_Euribor365_SWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor365 *) ((Euribor365_SW *) x));
}
static void *_p_Euribor3MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor3M *) x));
}
static void *_p_Euribor3WTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor3W *) x));
}
static void *_p_Euribor4MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor4M *) x));
}
static void *_p_Euribor5MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor5M *) x));
}
static void *_p_Euribor6MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor6M *) x));
}
static void *_p_Euribor7MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor7M *) x));
}
static void *_p_Euribor8MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor8M *) x));
}
static void *_p_Euribor9MTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((Euribor9M *) x));
}
static void *_p_EuriborSWTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(Euribor *) ((EuriborSW *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EuriborSwapIfrFix *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((EuriborSwapIsdaFixB *) x));
}
static void *_p_FedFundsTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((FedFunds *) x));
}
static void *_p_GBPLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((GBPLibor *) x));
}
static void *_p_GBPLiborONTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_IborIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *)  ((IborIndex *) x));
}
static void *_p_JPYLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((JPYLibor *) x));
}
static void *_p_JibarTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Jibar *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_JpyLiborSwapIsdaFixPmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_LiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Libor *) x));
}
static void *_p_MosprimeTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Mosprime *) x));
}
static void *_p_NZDLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((NZDLibor *) x));
}
static void *_p_NzocrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Nzocr *) x));
}
static void *_p_OvernightIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((OvernightIndex *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((OvernightIndexedSwapIndex *) x));
}
static void *_p_PriborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Pribor *) x));
}
static void *_p_RoborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Robor *) x));
}
static void *_p_SEKLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((SEKLibor *) x));
}
static void *_p_ShiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Shibor *) x));
}
static void *_p_SofrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Sofr *) x));
}
static void *_p_SoniaTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Sonia *) x));
}
static void *_p_SwapIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *)  ((SwapIndex *) x));
}
static void *_p_SwapSpreadIndexTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *)  ((SwapSpreadIndex *) x));
}
static void *_p_SwestrTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(OvernightIndex *) ((Swestr *) x));
}
static void *_p_THBFIXTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((THBFIX *) x));
}
static void *_p_TRLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((TRLibor *) x));
}
static void *_p_TiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Tibor *) x));
}
static void *_p_USDLiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((USDLibor *) x));
}
static void *_p_USDLiborONTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *)(DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (SwapIndex *) ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_WiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Wibor *) x));
}
static void *_p_ZiborTo_p_InterestRateIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((InterestRateIndex *) (IborIndex *) ((Zibor *) x));
}
static void *_p_AmortizingCmsRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((AmortizingCmsRateBond *) x));
}
static void *_p_AmortizingFixedRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((AmortizingFixedRateBond *) x));
}
static void *_p_AmortizingFloatingRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((AmortizingFloatingRateBond *) x));
}
static void *_p_ArithmeticAverageOISTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((ArithmeticAverageOIS *) x));
}
static void *_p_AssetSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((AssetSwap *) x));
}
static void *_p_BarrierOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_BasketOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_BondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((Bond *) x));
}
static void *_p_BondForwardTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Forward *) ((BondForward *) x));
}
static void *_p_CPIBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((CPIBond *) x));
}
static void *_p_CPISwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((CPISwap *) x));
}
static void *_p_CallableBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((CallableBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *)(CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *)(CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_CapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(CapFloor *) ((Cap *) x));
}
static void *_p_CapFloorTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((CapFloor *) x));
}
static void *_p_CdsOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *) ((CdsOption *) x));
}
static void *_p_CliquetOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((CliquetOption *) x));
}
static void *_p_CmsRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((CmsRateBond *) x));
}
static void *_p_CollarTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(CapFloor *) ((Collar *) x));
}
static void *_p_ComplexChooserOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((ComplexChooserOption *) x));
}
static void *_p_CompositeInstrumentTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((CompositeInstrument *) x));
}
static void *_p_CompoundOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((CompoundOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_ContinuousFixedLookbackOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((ContinuousFixedLookbackOption *) x));
}
static void *_p_ContinuousFloatingLookbackOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((ContinuousFloatingLookbackOption *) x));
}
static void *_p_ContinuousPartialFixedLookbackOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(ContinuousFixedLookbackOption *) ((ContinuousPartialFixedLookbackOption *) x));
}
static void *_p_ContinuousPartialFloatingLookbackOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(ContinuousFloatingLookbackOption *) ((ContinuousPartialFloatingLookbackOption *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((ConvertibleFixedCouponBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((ConvertibleFloatingRateBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((ConvertibleZeroCouponBond *) x));
}
static void *_p_CreditDefaultSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((CreditDefaultSwap *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((DividendVanillaOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_EquityTotalReturnSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((EquityTotalReturnSwap *) x));
}
static void *_p_EuropeanOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_EverestOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(MultiAssetOption *) ((EverestOption *) x));
}
static void *_p_FixedRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((FixedRateBond *) x));
}
static void *_p_FixedRateBondForwardTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Forward *)(BondForward *) ((FixedRateBondForward *) x));
}
static void *_p_FloatFloatSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((FloatFloatSwap *) x));
}
static void *_p_FloatFloatSwaptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((FloatFloatSwaption *) x));
}
static void *_p_FloatingRateBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((FloatingRateBond *) x));
}
static void *_p_FloorTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(CapFloor *) ((Floor *) x));
}
static void *_p_ForwardTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((Forward *) x));
}
static void *_p_ForwardRateAgreementTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((ForwardRateAgreement *) x));
}
static void *_p_ForwardVanillaOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((ForwardVanillaOption *) x));
}
static void *_p_HimalayaOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_InstrumentTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *)  ((Instrument *) x));
}
static void *_p_MargrabeOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(MultiAssetOption *) ((MargrabeOption *) x));
}
static void *_p_MultiAssetOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *) ((MultiAssetOption *) x));
}
static void *_p_NonstandardSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((NonstandardSwap *) x));
}
static void *_p_NonstandardSwaptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((NonstandardSwaption *) x));
}
static void *_p_OneAssetOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *) ((OneAssetOption *) x));
}
static void *_p_OptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((Option *) x));
}
static void *_p_OvernightIndexFutureTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((OvernightIndexFuture *) x));
}
static void *_p_OvernightIndexedSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((OvernightIndexedSwap *) x));
}
static void *_p_PartialTimeBarrierOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((PartialTimeBarrierOption *) x));
}
static void *_p_QuantoBarrierOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(BarrierOption *) ((QuantoBarrierOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *)(ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((QuantoVanillaOption *) x));
}
static void *_p_SimpleChooserOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((SimpleChooserOption *) x));
}
static void *_p_SpreadOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_StockTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((Stock *) x));
}
static void *_p_SwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((Swap *) x));
}
static void *_p_SwaptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *) ((Swaption *) x));
}
static void *_p_VanillaOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((VanillaOption *) x));
}
static void *_p_VanillaSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((VanillaSwap *) x));
}
static void *_p_VanillaSwingOptionTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Option *)(OneAssetOption *) ((VanillaSwingOption *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((YearOnYearInflationSwap *) x));
}
static void *_p_YoYInflationCapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(YoYInflationCapFloor *) ((YoYInflationCap *) x));
}
static void *_p_YoYInflationCapFloorTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *) ((YoYInflationCapFloor *) x));
}
static void *_p_YoYInflationCollarTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(YoYInflationCapFloor *) ((YoYInflationCollar *) x));
}
static void *_p_YoYInflationFloorTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(YoYInflationCapFloor *) ((YoYInflationFloor *) x));
}
static void *_p_ZeroCouponBondTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Bond *) ((ZeroCouponBond *) x));
}
static void *_p_ZeroCouponInflationSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((ZeroCouponInflationSwap *) x));
}
static void *_p_ZeroCouponSwapTo_p_LazyObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LazyObject *) (Instrument *)(Swap *) ((ZeroCouponSwap *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_LocalVolSurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolSurface *)  ((NoExceptLocalVolSurface *) x));
}
static void *_p_AndreasenHugeLocalVolAdapterTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *)  ((AndreasenHugeLocalVolAdapter *) x));
}
static void *_p_FixedLocalVolSurfaceTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *)  ((FixedLocalVolSurface *) x));
}
static void *_p_GridModelLocalVolSurfaceTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *)  ((GridModelLocalVolSurface *) x));
}
static void *_p_LocalConstantVolTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *)  ((LocalConstantVol *) x));
}
static void *_p_LocalVolSurfaceTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *)  ((LocalVolSurface *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_LocalVolTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((LocalVolTermStructure *) (LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_AbcdVolTo_p_MarketModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MarketModel *)  ((AbcdVol *) x));
}
static void *_p_LogNormalFwdRateIpcTo_p_MarketModelEvolver(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MarketModelEvolver *)  ((LogNormalFwdRateIpc *) x));
}
static void *_p_BasketOptionTo_p_MultiAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MultiAssetOption *)  ((BasketOption *) x));
}
static void *_p_EverestOptionTo_p_MultiAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MultiAssetOption *)  ((EverestOption *) x));
}
static void *_p_HimalayaOptionTo_p_MultiAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MultiAssetOption *)  ((HimalayaOption *) x));
}
static void *_p_MargrabeOptionTo_p_MultiAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MultiAssetOption *)  ((MargrabeOption *) x));
}
static void *_p_SpreadOptionTo_p_MultiAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((MultiAssetOption *)  ((SpreadOption *) x));
}
static void *_p_SecondOrderMixedDerivativeOpTo_p_NinePointLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((NinePointLinearOp *)  ((SecondOrderMixedDerivativeOp *) x));
}
static void *_p_AUCPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((AUCPI *) x));
}
static void *_p_AUDLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((AUDLibor *) x));
}
static void *_p_AmortizingCmsRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((AmortizingCmsRateBond *) x));
}
static void *_p_AmortizingFixedRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((AmortizingFixedRateBond *) x));
}
static void *_p_AmortizingFloatingRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((AmortizingFloatingRateBond *) x));
}
static void *_p_AmortizingPaymentTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((AmortizingPayment *) x));
}
static void *_p_AnalyticAmericanMargrabeEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticAmericanMargrabeEngine *) x));
}
static void *_p_AnalyticBSMHullWhiteEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticBSMHullWhiteEngine *) x));
}
static void *_p_AnalyticBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticBarrierEngine *) x));
}
static void *_p_AnalyticBinaryBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticBinaryBarrierEngine *) x));
}
static void *_p_AnalyticCEVEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticCEVEngine *) x));
}
static void *_p_AnalyticCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticCapFloorEngine *) x));
}
static void *_p_AnalyticCliquetEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticCliquetEngine *) x));
}
static void *_p_AnalyticComplexChooserEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticComplexChooserEngine *) x));
}
static void *_p_AnalyticCompoundOptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticCompoundOptionEngine *) x));
}
static void *_p_AnalyticContinuousFixedLookbackEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousFixedLookbackEngine *) x));
}
static void *_p_AnalyticContinuousFloatingLookbackEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousFloatingLookbackEngine *) x));
}
static void *_p_AnalyticContinuousGeometricAveragePriceAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousGeometricAveragePriceAsianEngine *) x));
}
static void *_p_AnalyticContinuousGeometricAveragePriceAsianHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousGeometricAveragePriceAsianHestonEngine *) x));
}
static void *_p_AnalyticContinuousPartialFixedLookbackEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousPartialFixedLookbackEngine *) x));
}
static void *_p_AnalyticContinuousPartialFloatingLookbackEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticContinuousPartialFloatingLookbackEngine *) x));
}
static void *_p_AnalyticDigitalAmericanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDigitalAmericanEngine *) x));
}
static void *_p_AnalyticDigitalAmericanKOEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDigitalAmericanKOEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAveragePriceAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDiscreteGeometricAveragePriceAsianEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAveragePriceAsianHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAverageStrikeAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDiscreteGeometricAverageStrikeAsianEngine *) x));
}
static void *_p_AnalyticDividendEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDividendEuropeanEngine *) x));
}
static void *_p_AnalyticDoubleBarrierBinaryEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDoubleBarrierBinaryEngine *) x));
}
static void *_p_AnalyticDoubleBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticDoubleBarrierEngine *) x));
}
static void *_p_AnalyticEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticEuropeanEngine *) x));
}
static void *_p_AnalyticEuropeanMargrabeEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticEuropeanMargrabeEngine *) x));
}
static void *_p_AnalyticGJRGARCHEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticGJRGARCHEngine *) x));
}
static void *_p_AnalyticH1HWEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticH1HWEngine *) x));
}
static void *_p_AnalyticHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticHestonEngine *) x));
}
static void *_p_AnalyticHestonForwardEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticHestonForwardEuropeanEngine *) x));
}
static void *_p_AnalyticHestonHullWhiteEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticHestonHullWhiteEngine *) x));
}
static void *_p_AnalyticPTDHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticPTDHestonEngine *) x));
}
static void *_p_AnalyticPartialTimeBarrierOptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticPartialTimeBarrierOptionEngine *) x));
}
static void *_p_AnalyticPerformanceEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticPerformanceEngine *) x));
}
static void *_p_AnalyticSimpleChooserEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((AnalyticSimpleChooserEngine *) x));
}
static void *_p_AndreasenHugeLocalVolAdapterTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((AndreasenHugeLocalVolAdapter *) x));
}
static void *_p_AndreasenHugeVolatilityAdapterTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((AndreasenHugeVolatilityAdapter *) x));
}
static void *_p_AndreasenHugeVolatilityInterplTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((AndreasenHugeVolatilityInterpl *) x));
}
static void *_p_AoniaTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Aonia *) x));
}
static void *_p_ArithmeticAverageOISTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((ArithmeticAverageOIS *) x));
}
static void *_p_ArithmeticOISRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((ArithmeticOISRateHelper *) x));
}
static void *_p_AssetSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((AssetSwap *) x));
}
static void *_p_BachelierCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BachelierCapFloorEngine *) x));
}
static void *_p_BachelierSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BachelierSwaptionEngine *) x));
}
static void *_p_BaroneAdesiWhaleyApproximationEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BaroneAdesiWhaleyApproximationEngine *) x));
}
static void *_p_BarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_BasketOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_BatesEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BatesEngine *) x));
}
static void *_p_BatesModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(HestonModel *) ((BatesModel *) x));
}
static void *_p_BatesProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(HestonProcess *) ((BatesProcess *) x));
}
static void *_p_BbswTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Bbsw *) x));
}
static void *_p_Bbsw1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw1M *) x));
}
static void *_p_Bbsw2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw2M *) x));
}
static void *_p_Bbsw3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw3M *) x));
}
static void *_p_Bbsw4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw4M *) x));
}
static void *_p_Bbsw5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw5M *) x));
}
static void *_p_Bbsw6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bbsw *) ((Bbsw6M *) x));
}
static void *_p_BiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Bibor *) x));
}
static void *_p_Bibor1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1M *) x));
}
static void *_p_Bibor1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor1Y *) x));
}
static void *_p_Bibor2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor2M *) x));
}
static void *_p_Bibor3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor3M *) x));
}
static void *_p_Bibor6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor6M *) x));
}
static void *_p_Bibor9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((Bibor9M *) x));
}
static void *_p_BiborSWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bibor *) ((BiborSW *) x));
}
static void *_p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_BinomialConvertibleEngineT_CoxRossRubinstein_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< CoxRossRubinstein > *) x));
}
static void *_p_BinomialConvertibleEngineT_JarrowRudd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< JarrowRudd > *) x));
}
static void *_p_BinomialConvertibleEngineT_Joshi4_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< Joshi4 > *) x));
}
static void *_p_BinomialConvertibleEngineT_LeisenReimer_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< LeisenReimer > *) x));
}
static void *_p_BinomialConvertibleEngineT_Tian_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< Tian > *) x));
}
static void *_p_BinomialConvertibleEngineT_Trigeorgis_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialConvertibleEngine< Trigeorgis > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_BinomialVanillaEngineT_CoxRossRubinstein_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< CoxRossRubinstein > *) x));
}
static void *_p_BinomialVanillaEngineT_JarrowRudd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< JarrowRudd > *) x));
}
static void *_p_BinomialVanillaEngineT_Joshi4_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< Joshi4 > *) x));
}
static void *_p_BinomialVanillaEngineT_LeisenReimer_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< LeisenReimer > *) x));
}
static void *_p_BinomialVanillaEngineT_Tian_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< Tian > *) x));
}
static void *_p_BinomialVanillaEngineT_Trigeorgis_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BinomialVanillaEngine< Trigeorgis > *) x));
}
static void *_p_BjerksundStenslandApproximationEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BjerksundStenslandApproximationEngine *) x));
}
static void *_p_BkbmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Bkbm *) x));
}
static void *_p_Bkbm1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm1M *) x));
}
static void *_p_Bkbm2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm2M *) x));
}
static void *_p_Bkbm3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm3M *) x));
}
static void *_p_Bkbm4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm4M *) x));
}
static void *_p_Bkbm5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm5M *) x));
}
static void *_p_Bkbm6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Bkbm *) ((Bkbm6M *) x));
}
static void *_p_BlackCallableFixedRateBondEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BlackCallableFixedRateBondEngine *) x));
}
static void *_p_BlackCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BlackCapFloorEngine *) x));
}
static void *_p_BlackCdsOptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BlackCdsOptionEngine *) x));
}
static void *_p_BlackConstantVolTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackConstantVol *) x));
}
static void *_p_BlackKarasinskiTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((BlackKarasinski *) x));
}
static void *_p_BlackProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((BlackProcess *) x));
}
static void *_p_BlackScholesMertonProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((BlackScholesMertonProcess *) x));
}
static void *_p_BlackScholesProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((BlackScholesProcess *) x));
}
static void *_p_BlackSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((BlackSwaptionEngine *) x));
}
static void *_p_BlackVarianceCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceCurve *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceSurface *) x));
}
static void *_p_BlackVolTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((BlackVolTermStructure *) x));
}
static void *_p_BondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((Bond *) x));
}
static void *_p_BondForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Forward *) ((BondForward *) x));
}
static void *_p_BondHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((BondHelper *) x));
}
static void *_p_BootstrapHelperT_YoYInflationTermStructure_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((BootstrapHelper< YoYInflationTermStructure > *) x));
}
static void *_p_BootstrapHelperT_YoYOptionletVolatilitySurface_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((BootstrapHelper< YoYOptionletVolatilitySurface > *) x));
}
static void *_p_BootstrapHelperT_ZeroInflationTermStructure_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((BootstrapHelper< ZeroInflationTermStructure > *) x));
}
static void *_p_CADLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((CADLibor *) x));
}
static void *_p_CADLiborONTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((CADLiborON *) x));
}
static void *_p_CHFLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((CHFLibor *) x));
}
static void *_p_COSHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((COSHestonEngine *) x));
}
static void *_p_CPIBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((CPIBond *) x));
}
static void *_p_CPICashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(IndexedCashFlow *) ((CPICashFlow *) x));
}
static void *_p_CPICouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(InflationCoupon *) ((CPICoupon *) x));
}
static void *_p_CPISwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((CPISwap *) x));
}
static void *_p_CalibratedModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((CalibratedModel *) x));
}
static void *_p_CallableBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((CallableBond *) x));
}
static void *_p_CallableFixedRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *)(CallableBond *) ((CallableFixedRateBond *) x));
}
static void *_p_CallableZeroCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *)(CallableBond *) ((CallableZeroCouponBond *) x));
}
static void *_p_CapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(CapFloor *) ((Cap *) x));
}
static void *_p_CapFloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((CapFloor *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolCurve *) x));
}
static void *_p_CapFloorTermVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolSurface *) x));
}
static void *_p_CapFloorTermVolatilityStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((CapFloorTermVolatilityStructure *) x));
}
static void *_p_CappedFlooredCmsCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsCoupon *) x));
}
static void *_p_CappedFlooredCmsSpreadCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredCmsSpreadCoupon *) x));
}
static void *_p_CappedFlooredCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((CappedFlooredCoupon *) x));
}
static void *_p_CappedFlooredIborCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *)(CappedFlooredCoupon *) ((CappedFlooredIborCoupon *) x));
}
static void *_p_CappedFlooredYoYInflationCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(InflationCoupon *)(YoYInflationCoupon *) ((CappedFlooredYoYInflationCoupon *) x));
}
static void *_p_CashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((CashFlow *) x));
}
static void *_p_CdorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Cdor *) x));
}
static void *_p_CdsOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *) ((CdsOption *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_CliquetOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((CliquetOption *) x));
}
static void *_p_CmsCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((CmsCoupon *) x));
}
static void *_p_CmsRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((CmsRateBond *) x));
}
static void *_p_CmsSpreadCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((CmsSpreadCoupon *) x));
}
static void *_p_CollarTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(CapFloor *) ((Collar *) x));
}
static void *_p_ComplexChooserOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((ComplexChooserOption *) x));
}
static void *_p_CompositeInstrumentTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((CompositeInstrument *) x));
}
static void *_p_CompositeQuoteT_BinaryFunction_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((CompositeQuote< BinaryFunction > *) x));
}
static void *_p_CompositeZeroYieldStructureT_BinaryFunction_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((CompositeZeroYieldStructure< BinaryFunction > *) x));
}
static void *_p_CompoundOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((CompoundOption *) x));
}
static void *_p_ConstNotionalCrossCurrencyBasisSwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((ConstNotionalCrossCurrencyBasisSwapRateHelper *) x));
}
static void *_p_ConstantOptionletVolatilityTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(OptionletVolatilityStructure *) ((ConstantOptionletVolatility *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((ConstantSwaptionVolatility *) x));
}
static void *_p_ConstantYoYOptionletVolatilityTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_ContinuousArithmeticAsianLevyEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((ContinuousArithmeticAsianLevyEngine *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_ContinuousFixedLookbackOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((ContinuousFixedLookbackOption *) x));
}
static void *_p_ContinuousFloatingLookbackOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((ContinuousFloatingLookbackOption *) x));
}
static void *_p_ContinuousPartialFixedLookbackOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(ContinuousFixedLookbackOption *) ((ContinuousPartialFixedLookbackOption *) x));
}
static void *_p_ContinuousPartialFloatingLookbackOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(ContinuousFloatingLookbackOption *) ((ContinuousPartialFloatingLookbackOption *) x));
}
static void *_p_ConvertibleFixedCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((ConvertibleFixedCouponBond *) x));
}
static void *_p_ConvertibleFloatingRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((ConvertibleFloatingRateBond *) x));
}
static void *_p_ConvertibleZeroCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((ConvertibleZeroCouponBond *) x));
}
static void *_p_CorraTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Corra *) x));
}
static void *_p_CouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((Coupon *) x));
}
static void *_p_CoxIngersollRossTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((CoxIngersollRoss *) x));
}
static void *_p_CreditDefaultSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((CreditDefaultSwap *) x));
}
static void *_p_DKKLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((DKKLibor *) x));
}
static void *_p_DailyTenorLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((DailyTenorLibor *) x));
}
static void *_p_DatedOISRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((DatedOISRateHelper *) x));
}
static void *_p_DefaultProbabilityHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((DefaultProbabilityHelper *) x));
}
static void *_p_DefaultProbabilityTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((DefaultProbabilityTermStructure *) x));
}
static void *_p_DeltaVolQuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((DeltaVolQuote *) x));
}
static void *_p_DepositRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((DepositRateHelper *) x));
}
static void *_p_DerivedQuoteT_UnaryFunction_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((DerivedQuote< UnaryFunction > *) x));
}
static void *_p_DestrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Destr *) x));
}
static void *_p_DiscountingBondEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((DiscountingBondEngine *) x));
}
static void *_p_DiscountingSwapEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((DiscountingSwapEngine *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_DividendTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((Dividend *) x));
}
static void *_p_DividendBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((DividendVanillaOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_EUHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((EUHICP *) x));
}
static void *_p_EUHICPXTTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((EUHICPXT *) x));
}
static void *_p_EURLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((EURLibor *) x));
}
static void *_p_EURLibor10MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor10M *) x));
}
static void *_p_EURLibor11MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor11M *) x));
}
static void *_p_EURLibor1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1M *) x));
}
static void *_p_EURLibor1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor1Y *) x));
}
static void *_p_EURLibor2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2M *) x));
}
static void *_p_EURLibor2WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor2W *) x));
}
static void *_p_EURLibor3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor3M *) x));
}
static void *_p_EURLibor4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor4M *) x));
}
static void *_p_EURLibor5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor5M *) x));
}
static void *_p_EURLibor6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor6M *) x));
}
static void *_p_EURLibor7MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor7M *) x));
}
static void *_p_EURLibor8MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor8M *) x));
}
static void *_p_EURLibor9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLibor9M *) x));
}
static void *_p_EURLiborSWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(EURLibor *) ((EURLiborSW *) x));
}
static void *_p_EoniaTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Eonia *) x));
}
static void *_p_EquityCashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(IndexedCashFlow *) ((EquityCashFlow *) x));
}
static void *_p_EquityIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *) ((EquityIndex *) x));
}
static void *_p_EquityTotalReturnSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((EquityTotalReturnSwap *) x));
}
static void *_p_EstrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Estr *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_EuriborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Euribor *) x));
}
static void *_p_Euribor10MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor10M *) x));
}
static void *_p_Euribor11MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor11M *) x));
}
static void *_p_Euribor1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1M *) x));
}
static void *_p_Euribor1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor1Y *) x));
}
static void *_p_Euribor2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2M *) x));
}
static void *_p_Euribor2WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor2W *) x));
}
static void *_p_Euribor365To_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Euribor365 *) x));
}
static void *_p_Euribor365_10MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_10M *) x));
}
static void *_p_Euribor365_11MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_11M *) x));
}
static void *_p_Euribor365_1MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_1M *) x));
}
static void *_p_Euribor365_1YTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_1Y *) x));
}
static void *_p_Euribor365_2MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_2M *) x));
}
static void *_p_Euribor365_2WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_2W *) x));
}
static void *_p_Euribor365_3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_3M *) x));
}
static void *_p_Euribor365_3WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_3W *) x));
}
static void *_p_Euribor365_4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_4M *) x));
}
static void *_p_Euribor365_5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_5M *) x));
}
static void *_p_Euribor365_6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_6M *) x));
}
static void *_p_Euribor365_7MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_7M *) x));
}
static void *_p_Euribor365_8MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_8M *) x));
}
static void *_p_Euribor365_9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_9M *) x));
}
static void *_p_Euribor365_SWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor365 *) ((Euribor365_SW *) x));
}
static void *_p_Euribor3MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3M *) x));
}
static void *_p_Euribor3WTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor3W *) x));
}
static void *_p_Euribor4MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor4M *) x));
}
static void *_p_Euribor5MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor5M *) x));
}
static void *_p_Euribor6MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor6M *) x));
}
static void *_p_Euribor7MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor7M *) x));
}
static void *_p_Euribor8MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor8M *) x));
}
static void *_p_Euribor9MTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((Euribor9M *) x));
}
static void *_p_EuriborSWTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(Euribor *) ((EuriborSW *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EuriborSwapIfrFix *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((EuriborSwapIsdaFixB *) x));
}
static void *_p_EuropeanOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_EverestOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(MultiAssetOption *) ((EverestOption *) x));
}
static void *_p_ExponentialFittingHestonEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((ExponentialFittingHestonEngine *) x));
}
static void *_p_ExtOUWithJumpsProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((ExtOUWithJumpsProcess *) x));
}
static void *_p_ExtendedCoxIngersollRossTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((ExtendedCoxIngersollRoss *) x));
}
static void *_p_ExtendedOrnsteinUhlenbeckProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((ExtendedOrnsteinUhlenbeckProcess *) x));
}
static void *_p_FFTVarianceGammaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FFTVarianceGammaEngine *) x));
}
static void *_p_FRHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((FRHICP *) x));
}
static void *_p_Fd2dBlackScholesVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Fd2dBlackScholesVanillaEngine *) x));
}
static void *_p_FdBatesVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBatesVanillaEngine *) x));
}
static void *_p_FdBlackScholesAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesAsianEngine *) x));
}
static void *_p_FdBlackScholesBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesBarrierEngine *) x));
}
static void *_p_FdBlackScholesRebateEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesRebateEngine *) x));
}
static void *_p_FdBlackScholesShoutEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesShoutEngine *) x));
}
static void *_p_FdBlackScholesVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdBlackScholesVanillaEngine *) x));
}
static void *_p_FdCEVVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdCEVVanillaEngine *) x));
}
static void *_p_FdG2SwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdG2SwaptionEngine *) x));
}
static void *_p_FdHestonBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonBarrierEngine *) x));
}
static void *_p_FdHestonDoubleBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonDoubleBarrierEngine *) x));
}
static void *_p_FdHestonHullWhiteVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonHullWhiteVanillaEngine *) x));
}
static void *_p_FdHestonRebateEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonRebateEngine *) x));
}
static void *_p_FdHestonVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHestonVanillaEngine *) x));
}
static void *_p_FdHullWhiteSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdHullWhiteSwaptionEngine *) x));
}
static void *_p_FdOrnsteinUhlenbeckVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdOrnsteinUhlenbeckVanillaEngine *) x));
}
static void *_p_FdSabrVanillaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdSabrVanillaEngine *) x));
}
static void *_p_FdSimpleBSSwingEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdSimpleBSSwingEngine *) x));
}
static void *_p_FdSimpleExtOUJumpSwingEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((FdSimpleExtOUJumpSwingEngine *) x));
}
static void *_p_FedFundsTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((FedFunds *) x));
}
static void *_p_FittedBondDiscountCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((FittedBondDiscountCurve *) x));
}
static void *_p_FixedDividendTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Dividend *) ((FixedDividend *) x));
}
static void *_p_FixedLocalVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((FixedLocalVolSurface *) x));
}
static void *_p_FixedRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((FixedRateBond *) x));
}
static void *_p_FixedRateBondForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Forward *)(BondForward *) ((FixedRateBondForward *) x));
}
static void *_p_FixedRateBondHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *)(BondHelper *) ((FixedRateBondHelper *) x));
}
static void *_p_FixedRateCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *) ((FixedRateCoupon *) x));
}
static void *_p_FlatForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((FlatForward *) x));
}
static void *_p_FlatHazardRateTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((FlatHazardRate *) x));
}
static void *_p_FlatSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((FlatSmileSection *) x));
}
static void *_p_FloatFloatSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((FloatFloatSwap *) x));
}
static void *_p_FloatFloatSwaptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((FloatFloatSwaption *) x));
}
static void *_p_FloatingRateBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((FloatingRateBond *) x));
}
static void *_p_FloatingRateCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *) ((FloatingRateCoupon *) x));
}
static void *_p_FloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(CapFloor *) ((Floor *) x));
}
static void *_p_ForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((Forward *) x));
}
static void *_p_ForwardEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((ForwardEuropeanEngine *) x));
}
static void *_p_ForwardRateAgreementTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((ForwardRateAgreement *) x));
}
static void *_p_ForwardSpreadedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((ForwardSpreadedTermStructure *) x));
}
static void *_p_ForwardVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((ForwardVanillaOption *) x));
}
static void *_p_FraRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((FraRateHelper *) x));
}
static void *_p_FractionalDividendTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Dividend *) ((FractionalDividend *) x));
}
static void *_p_FuturesRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((FuturesRateHelper *) x));
}
static void *_p_FxSwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((FxSwapRateHelper *) x));
}
static void *_p_G2To_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((G2 *) x));
}
static void *_p_G2ForwardProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((G2ForwardProcess *) x));
}
static void *_p_G2ProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((G2Process *) x));
}
static void *_p_G2SwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((G2SwaptionEngine *) x));
}
static void *_p_GBPLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((GBPLibor *) x));
}
static void *_p_GBPLiborONTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((GBPLiborON *) x));
}
static void *_p_GJRGARCHModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((GJRGARCHModel *) x));
}
static void *_p_GJRGARCHProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((GJRGARCHProcess *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((GarmanKohlagenProcess *) x));
}
static void *_p_Gaussian1dCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dCapFloorEngine *) x));
}
static void *_p_Gaussian1dFloatFloatSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dFloatFloatSwaptionEngine *) x));
}
static void *_p_Gaussian1dJamshidianSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dJamshidianSwaptionEngine *) x));
}
static void *_p_Gaussian1dModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructureConsistentModel *) ((Gaussian1dModel *) x));
}
static void *_p_Gaussian1dNonstandardSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dNonstandardSwaptionEngine *) x));
}
static void *_p_Gaussian1dSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((Gaussian1dSwaptionEngine *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_GeneralizedBlackScholesProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((GeneralizedBlackScholesProcess *) x));
}
static void *_p_GeometricBrownianMotionProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((GeometricBrownianMotionProcess *) x));
}
static void *_p_GlobalLinearSimpleZeroCurveTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((GlobalLinearSimpleZeroCurve *) x));
}
static void *_p_GridModelLocalVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((GridModelLocalVolSurface *) x));
}
static void *_p_GsrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructureConsistentModel *)(Gaussian1dModel *) ((Gsr *) x));
}
static void *_p_GsrProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((GsrProcess *) x));
}
static void *_p_HestonBlackVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(BlackVolTermStructure *) ((HestonBlackVolSurface *) x));
}
static void *_p_HestonModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((HestonModel *) x));
}
static void *_p_HestonProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((HestonProcess *) x));
}
static void *_p_HestonSLVProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((HestonSLVProcess *) x));
}
static void *_p_HimalayaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_HullWhiteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *)(OneFactorAffineModel *)(Vasicek *) ((HullWhite *) x));
}
static void *_p_HullWhiteForwardProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((HullWhiteForwardProcess *) x));
}
static void *_p_HullWhiteProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((HullWhiteProcess *) x));
}
static void *_p_IborCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((IborCoupon *) x));
}
static void *_p_IborIborBasisSwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((IborIborBasisSwapRateHelper *) x));
}
static void *_p_IborIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *) ((IborIndex *) x));
}
static void *_p_ImpliedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((ImpliedTermStructure *) x));
}
static void *_p_IndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((Index *) x));
}
static void *_p_IndexedCashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((IndexedCashFlow *) x));
}
static void *_p_InflationCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *) ((InflationCoupon *) x));
}
static void *_p_InflationIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *) ((InflationIndex *) x));
}
static void *_p_InflationTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((InflationTermStructure *) x));
}
static void *_p_InstrumentTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *) ((Instrument *) x));
}
static void *_p_IntegralCdsEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((IntegralCdsEngine *) x));
}
static void *_p_IntegralEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((IntegralEngine *) x));
}
static void *_p_InterestRateIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *) ((InterestRateIndex *) x));
}
static void *_p_InterpolatedDefaultDensityCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((InterpolatedDefaultDensityCurve< Linear > *) x));
}
static void *_p_InterpolatedDiscountCurveT_KrugerLog_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< KrugerLog > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogLinear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< LogLinear > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogMixedLinearCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< LogMixedLinearCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_MonotonicLogCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< MonotonicLogCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_SplineCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< SplineCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_SplineLogCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedDiscountCurve< SplineLogCubic > *) x));
}
static void *_p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedForwardCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((InterpolatedHazardRateCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedSmileSectionT_Cubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((InterpolatedSmileSection< Cubic > *) x));
}
static void *_p_InterpolatedSmileSectionT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((InterpolatedSmileSection< Linear > *) x));
}
static void *_p_InterpolatedSmileSectionT_MonotonicCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((InterpolatedSmileSection< MonotonicCubic > *) x));
}
static void *_p_InterpolatedSmileSectionT_SplineCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((InterpolatedSmileSection< SplineCubic > *) x));
}
static void *_p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((InterpolatedSurvivalProbabilityCurve< Linear > *) x));
}
static void *_p_InterpolatedSwaptionVolatilityCubeTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((InterpolatedSwaptionVolatilityCube *) x));
}
static void *_p_InterpolatedYoYInflationCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(YoYInflationTermStructure *) ((InterpolatedYoYInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((InterpolatedYoYOptionletVolatilityCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroCurveT_Cubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< Cubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< DefaultLogCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_Kruger_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< Kruger > *) x));
}
static void *_p_InterpolatedZeroCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroCurveT_LogLinear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< LogLinear > *) x));
}
static void *_p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< MonotonicCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_SplineCubic_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((InterpolatedZeroCurve< SplineCubic > *) x));
}
static void *_p_InterpolatedZeroInflationCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(ZeroInflationTermStructure *) ((InterpolatedZeroInflationCurve< Linear > *) x));
}
static void *_p_IsdaCdsEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((IsdaCdsEngine *) x));
}
static void *_p_JPYLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((JPYLibor *) x));
}
static void *_p_JamshidianSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((JamshidianSwaptionEngine *) x));
}
static void *_p_JibarTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Jibar *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_JpyLiborSwapIsdaFixPmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_JuQuadraticApproximationEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((JuQuadraticApproximationEngine *) x));
}
static void *_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((KInterpolatedYoYOptionletVolatilitySurface< Linear > *) x));
}
static void *_p_KahaleSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((KahaleSmileSection *) x));
}
static void *_p_KirkEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((KirkEngine *) x));
}
static void *_p_KirkSpreadOptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((KirkSpreadOptionEngine *) x));
}
static void *_p_KlugeExtOUProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((KlugeExtOUProcess *) x));
}
static void *_p_LastFixingQuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((LastFixingQuote *) x));
}
static void *_p_LazyObjectTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((LazyObject *) x));
}
static void *_p_LiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Libor *) x));
}
static void *_p_LocalConstantVolTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalConstantVol *) x));
}
static void *_p_LocalVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalVolSurface *) x));
}
static void *_p_LocalVolTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((LocalVolTermStructure *) x));
}
static void *_p_MCAmericanBasketEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanBasketEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCAmericanEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCAmericanEngine< PseudoRandom > *) x));
}
static void *_p_MCBarrierEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCBarrierEngine< LowDiscrepancy > *) x));
}
static void *_p_MCBarrierEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCBarrierEngine< PseudoRandom > *) x));
}
static void *_p_MCDigitalEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDigitalEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDigitalEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDigitalEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticAPEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticASEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteArithmeticASEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteGeometricAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteGeometricAPEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCDiscreteGeometricAPHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanBasketEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanBasketEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanGJRGARCHEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanGJRGARCHEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanHestonEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanHestonEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEuropeanHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCEverestEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEverestEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEverestEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCEverestEngine< PseudoRandom > *) x));
}
static void *_p_MCForwardEuropeanBSEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCForwardEuropeanBSEngine< LowDiscrepancy > *) x));
}
static void *_p_MCForwardEuropeanBSEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCForwardEuropeanBSEngine< PseudoRandom > *) x));
}
static void *_p_MCForwardEuropeanHestonEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCForwardEuropeanHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCForwardEuropeanHestonEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCForwardEuropeanHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCHimalayaEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCHimalayaEngine< LowDiscrepancy > *) x));
}
static void *_p_MCHimalayaEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCHimalayaEngine< PseudoRandom > *) x));
}
static void *_p_MCPerformanceEngineT_LowDiscrepancy_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCPerformanceEngine< LowDiscrepancy > *) x));
}
static void *_p_MCPerformanceEngineT_PseudoRandom_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MCPerformanceEngine< PseudoRandom > *) x));
}
static void *_p_MargrabeOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(MultiAssetOption *) ((MargrabeOption *) x));
}
static void *_p_MarkovFunctionalTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructureConsistentModel *)(Gaussian1dModel *) ((MarkovFunctional *) x));
}
static void *_p_Merton76ProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((Merton76Process *) x));
}
static void *_p_MidPointCdsEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((MidPointCdsEngine *) x));
}
static void *_p_MosprimeTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Mosprime *) x));
}
static void *_p_MtMCrossCurrencyBasisSwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((MtMCrossCurrencyBasisSwapRateHelper *) x));
}
static void *_p_MultiAssetOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *) ((MultiAssetOption *) x));
}
static void *_p_NZDLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((NZDLibor *) x));
}
static void *_p_NoArbSabrInterpolatedSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((NoArbSabrInterpolatedSmileSection *) x));
}
static void *_p_NoArbSabrSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((NoArbSabrSmileSection *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(LocalVolTermStructure *)(LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_NonstandardSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((NonstandardSwap *) x));
}
static void *_p_NonstandardSwaptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((NonstandardSwaption *) x));
}
static void *_p_NzocrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Nzocr *) x));
}
static void *_p_OISRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((OISRateHelper *) x));
}
static void *_p_OneAssetOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *) ((OneAssetOption *) x));
}
static void *_p_OneFactorAffineModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *) ((OneFactorAffineModel *) x));
}
static void *_p_OptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((Option *) x));
}
static void *_p_OptionletVolatilityStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((OptionletVolatilityStructure *) x));
}
static void *_p_OrnsteinUhlenbeckProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((OrnsteinUhlenbeckProcess *) x));
}
static void *_p_OvernightIborBasisSwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((OvernightIborBasisSwapRateHelper *) x));
}
static void *_p_OvernightIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((OvernightIndex *) x));
}
static void *_p_OvernightIndexFutureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((OvernightIndexFuture *) x));
}
static void *_p_OvernightIndexFutureRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((OvernightIndexFutureRateHelper *) x));
}
static void *_p_OvernightIndexedCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((OvernightIndexedCoupon *) x));
}
static void *_p_OvernightIndexedSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((OvernightIndexedSwap *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((OvernightIndexedSwapIndex *) x));
}
static void *_p_PartialTimeBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((PartialTimeBarrierOption *) x));
}
static void *_p_PiecewiseConvexMonotoneForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseConvexMonotoneForward *) x));
}
static void *_p_PiecewiseConvexMonotoneZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseConvexMonotoneZero *) x));
}
static void *_p_PiecewiseCubicZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseCubicZero *) x));
}
static void *_p_PiecewiseFlatForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseFlatForward *) x));
}
static void *_p_PiecewiseFlatHazardRateTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(DefaultProbabilityTermStructure *) ((PiecewiseFlatHazardRate *) x));
}
static void *_p_PiecewiseKrugerLogDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseKrugerLogDiscount *) x));
}
static void *_p_PiecewiseKrugerZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseKrugerZero *) x));
}
static void *_p_PiecewiseLinearForwardTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLinearForward *) x));
}
static void *_p_PiecewiseLinearZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLinearZero *) x));
}
static void *_p_PiecewiseLogCubicDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLogCubicDiscount *) x));
}
static void *_p_PiecewiseLogLinearDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLogLinearDiscount *) x));
}
static void *_p_PiecewiseLogMixedLinearCubicDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseLogMixedLinearCubicDiscount *) x));
}
static void *_p_PiecewiseNaturalCubicZeroTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseNaturalCubicZero *) x));
}
static void *_p_PiecewiseNaturalLogCubicDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseNaturalLogCubicDiscount *) x));
}
static void *_p_PiecewiseSplineCubicDiscountTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseSplineCubicDiscount *) x));
}
static void *_p_PiecewiseTimeDependentHestonModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((PiecewiseTimeDependentHestonModel *) x));
}
static void *_p_PiecewiseYoYInflationCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(YoYInflationTermStructure *) ((PiecewiseYoYInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseZeroInflationCurveT_Linear_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(ZeroInflationTermStructure *) ((PiecewiseZeroInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseZeroSpreadedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((PiecewiseZeroSpreadedTermStructure *) x));
}
static void *_p_PriborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Pribor *) x));
}
static void *_p_PricingEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((PricingEngine *) x));
}
static void *_p_QdFpAmericanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QdFpAmericanEngine *) x));
}
static void *_p_QdPlusAmericanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QdPlusAmericanEngine *) x));
}
static void *_p_QuantoBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QuantoBarrierEngine *) x));
}
static void *_p_QuantoBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(BarrierOption *) ((QuantoBarrierOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_QuantoEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QuantoEuropeanEngine *) x));
}
static void *_p_QuantoForwardEuropeanEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((QuantoForwardEuropeanEngine *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *)(ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_QuantoTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((QuantoTermStructure *) x));
}
static void *_p_QuantoVanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((QuantoVanillaOption *) x));
}
static void *_p_QuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((Quote *) x));
}
static void *_p_RateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((RateHelper *) x));
}
static void *_p_RedemptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((Redemption *) x));
}
static void *_p_RiskyBondEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((RiskyBondEngine *) x));
}
static void *_p_RoborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Robor *) x));
}
static void *_p_SEKLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((SEKLibor *) x));
}
static void *_p_SabrSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((SabrSmileSection *) x));
}
static void *_p_SabrSwaptionVolatilityCubeTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SabrSwaptionVolatilityCube *) x));
}
static void *_p_ShiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Shibor *) x));
}
static void *_p_ShortRateModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *) ((ShortRateModel *) x));
}
static void *_p_SimpleCashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((SimpleCashFlow *) x));
}
static void *_p_SimpleChooserOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((SimpleChooserOption *) x));
}
static void *_p_SimpleQuoteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Quote *) ((SimpleQuote *) x));
}
static void *_p_SmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((SmileSection *) x));
}
static void *_p_SofrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sofr *) x));
}
static void *_p_SofrFutureRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *)(OvernightIndexFutureRateHelper *) ((SofrFutureRateHelper *) x));
}
static void *_p_SoniaTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Sonia *) x));
}
static void *_p_SpreadCdsHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (DefaultProbabilityHelper *) ((SpreadCdsHelper *) x));
}
static void *_p_SpreadOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_SpreadedBackwardFlatZeroInterpolatedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((SpreadedBackwardFlatZeroInterpolatedTermStructure *) x));
}
static void *_p_SpreadedLinearZeroInterpolatedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((SpreadedLinearZeroInterpolatedTermStructure *) x));
}
static void *_p_StochasticProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((StochasticProcess *) x));
}
static void *_p_StochasticProcess1DTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((StochasticProcess1D *) x));
}
static void *_p_StochasticProcessArrayTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *) ((StochasticProcessArray *) x));
}
static void *_p_StockTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((Stock *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(OptionletVolatilityStructure *) ((StrippedOptionletAdapter *) x));
}
static void *_p_StulzEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((StulzEngine *) x));
}
static void *_p_SubPeriodsCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(FloatingRateCoupon *) ((SubPeriodsCoupon *) x));
}
static void *_p_SuoWangDoubleBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((SuoWangDoubleBarrierEngine *) x));
}
static void *_p_SviInterpolatedSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((SviInterpolatedSmileSection *) x));
}
static void *_p_SviSmileSectionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((SviSmileSection *) x));
}
static void *_p_SwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((Swap *) x));
}
static void *_p_SwapIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *) ((SwapIndex *) x));
}
static void *_p_SwapRateHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (RateHelper *) ((SwapRateHelper *) x));
}
static void *_p_SwapSpreadIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *) ((SwapSpreadIndex *) x));
}
static void *_p_SwaptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *) ((Swaption *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((SwaptionVolatilityDiscrete *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_SwaptionVolatilityStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((SwaptionVolatilityStructure *) x));
}
static void *_p_SwestrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(OvernightIndex *) ((Swestr *) x));
}
static void *_p_THBFIXTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((THBFIX *) x));
}
static void *_p_TRLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((TRLibor *) x));
}
static void *_p_TermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((TermStructure *) x));
}
static void *_p_TermStructureConsistentModelTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *)  ((TermStructureConsistentModel *) x));
}
static void *_p_TiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Tibor *) x));
}
static void *_p_TreeCallableFixedRateBondEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TreeCallableFixedRateBondEngine *) x));
}
static void *_p_TreeCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TreeCapFloorEngine *) x));
}
static void *_p_TreeSwaptionEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TreeSwaptionEngine *) x));
}
static void *_p_TurnbullWakemanAsianEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((TurnbullWakemanAsianEngine *) x));
}
static void *_p_UKHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((UKHICP *) x));
}
static void *_p_UKRPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((UKRPI *) x));
}
static void *_p_USCPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((USCPI *) x));
}
static void *_p_USDLiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((USDLibor *) x));
}
static void *_p_USDLiborONTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *)(DailyTenorLibor *) ((USDLiborON *) x));
}
static void *_p_UltimateForwardTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((UltimateForwardTermStructure *) x));
}
static void *_p_UpfrontCdsHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (DefaultProbabilityHelper *) ((UpfrontCdsHelper *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(SwapIndex *) ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_VanillaOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((VanillaOption *) x));
}
static void *_p_VanillaSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((VanillaSwap *) x));
}
static void *_p_VanillaSwingOptionTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Option *)(OneAssetOption *) ((VanillaSwingOption *) x));
}
static void *_p_VannaVolgaBarrierEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VannaVolgaBarrierEngine *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *) x));
}
static void *_p_VarianceGammaEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((VarianceGammaEngine *) x));
}
static void *_p_VarianceGammaProcessTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (StochasticProcess *)(StochasticProcess1D *) ((VarianceGammaProcess *) x));
}
static void *_p_VasicekTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CalibratedModel *)(ShortRateModel *)(OneFactorAffineModel *) ((Vasicek *) x));
}
static void *_p_VolatilityTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((VolatilityTermStructure *) x));
}
static void *_p_WiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Wibor *) x));
}
static void *_p_YYEUHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYEUHICP *) x));
}
static void *_p_YYEUHICPXTTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYEUHICPXT *) x));
}
static void *_p_YYEUHICPrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYEUHICPr *) x));
}
static void *_p_YYFRHICPTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYFRHICP *) x));
}
static void *_p_YYFRHICPrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYFRHICPr *) x));
}
static void *_p_YYUKRPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUKRPI *) x));
}
static void *_p_YYUKRPIrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUKRPIr *) x));
}
static void *_p_YYUSCPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUSCPI *) x));
}
static void *_p_YYUSCPIrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYUSCPIr *) x));
}
static void *_p_YYZACPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYZACPI *) x));
}
static void *_p_YYZACPIrTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(YoYInflationIndex *) ((YYZACPIr *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((YearOnYearInflationSwap *) x));
}
static void *_p_YearOnYearInflationSwapHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (BootstrapHelper< YoYInflationTermStructure > *) ((YearOnYearInflationSwapHelper *) x));
}
static void *_p_YieldTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *) ((YieldTermStructure *) x));
}
static void *_p_YoYCapFloorTermPriceSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *) ((YoYCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationBachelierCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((YoYInflationBachelierCapFloorEngine *) x));
}
static void *_p_YoYInflationBlackCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((YoYInflationBlackCapFloorEngine *) x));
}
static void *_p_YoYInflationCapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(YoYInflationCapFloor *) ((YoYInflationCap *) x));
}
static void *_p_YoYInflationCapFloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *) ((YoYInflationCapFloor *) x));
}
static void *_p_YoYInflationCapFloorTermPriceSurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *)(YoYCapFloorTermPriceSurface *) ((YoYInflationCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationCollarTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(YoYInflationCapFloor *) ((YoYInflationCollar *) x));
}
static void *_p_YoYInflationCouponTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *)(Coupon *)(InflationCoupon *) ((YoYInflationCoupon *) x));
}
static void *_p_YoYInflationFloorTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(YoYInflationCapFloor *) ((YoYInflationFloor *) x));
}
static void *_p_YoYInflationIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *) ((YoYInflationIndex *) x));
}
static void *_p_YoYInflationTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *) ((YoYInflationTermStructure *) x));
}
static void *_p_YoYInflationUnitDisplacedBlackCapFloorEngineTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (PricingEngine *) ((YoYInflationUnitDisplacedBlackCapFloorEngine *) x));
}
static void *_p_YoYOptionletHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (BootstrapHelper< YoYOptionletVolatilitySurface > *) ((YoYOptionletHelper *) x));
}
static void *_p_YoYOptionletVolatilitySurfaceTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(VolatilityTermStructure *) ((YoYOptionletVolatilitySurface *) x));
}
static void *_p_ZACPITo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *)(ZeroInflationIndex *) ((ZACPI *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrFullFd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrFullFd > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrFullFd_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrFullFd > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrLocalVolatility_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityLognormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityNormal_tTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (SmileSection *) ((ZabrSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_ZeroCouponBondTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Bond *) ((ZeroCouponBond *) x));
}
static void *_p_ZeroCouponInflationSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((ZeroCouponInflationSwap *) x));
}
static void *_p_ZeroCouponInflationSwapHelperTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (BootstrapHelper< ZeroInflationTermStructure > *) ((ZeroCouponInflationSwapHelper *) x));
}
static void *_p_ZeroCouponSwapTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (LazyObject *)(Instrument *)(Swap *) ((ZeroCouponSwap *) x));
}
static void *_p_ZeroInflationCashFlowTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (CashFlow *) ((ZeroInflationCashFlow *) x));
}
static void *_p_ZeroInflationIndexTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InflationIndex *) ((ZeroInflationIndex *) x));
}
static void *_p_ZeroInflationTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(InflationTermStructure *) ((ZeroInflationTermStructure *) x));
}
static void *_p_ZeroSpreadedTermStructureTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (TermStructure *)(YieldTermStructure *) ((ZeroSpreadedTermStructure *) x));
}
static void *_p_ZiborTo_p_Observable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Observable *) (Index *)(InterestRateIndex *)(IborIndex *) ((Zibor *) x));
}
static void *_p_BarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((BarrierOption *) x));
}
static void *_p_CliquetOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((CliquetOption *) x));
}
static void *_p_ComplexChooserOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ComplexChooserOption *) x));
}
static void *_p_CompoundOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((CompoundOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ContinuousAveragingAsianOption *) x));
}
static void *_p_ContinuousFixedLookbackOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ContinuousFixedLookbackOption *) x));
}
static void *_p_ContinuousFloatingLookbackOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ContinuousFloatingLookbackOption *) x));
}
static void *_p_ContinuousPartialFixedLookbackOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (ContinuousFixedLookbackOption *) ((ContinuousPartialFixedLookbackOption *) x));
}
static void *_p_ContinuousPartialFloatingLookbackOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (ContinuousFloatingLookbackOption *) ((ContinuousPartialFloatingLookbackOption *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((DiscreteAveragingAsianOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((DividendVanillaOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((DoubleBarrierOption *) x));
}
static void *_p_EuropeanOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_ForwardVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((ForwardVanillaOption *) x));
}
static void *_p_PartialTimeBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((PartialTimeBarrierOption *) x));
}
static void *_p_QuantoBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (BarrierOption *) ((QuantoBarrierOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *) (ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((QuantoVanillaOption *) x));
}
static void *_p_SimpleChooserOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((SimpleChooserOption *) x));
}
static void *_p_VanillaOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((VanillaOption *) x));
}
static void *_p_VanillaSwingOptionTo_p_OneAssetOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneAssetOption *)  ((VanillaSwingOption *) x));
}
static void *_p_HullWhiteTo_p_OneFactorAffineModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneFactorAffineModel *) (Vasicek *) ((HullWhite *) x));
}
static void *_p_VasicekTo_p_OneFactorAffineModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OneFactorAffineModel *)  ((Vasicek *) x));
}
static void *_p_BFGSTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((BFGS *) x));
}
static void *_p_ConjugateGradientTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((ConjugateGradient *) x));
}
static void *_p_DifferentialEvolutionTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((DifferentialEvolution *) x));
}
static void *_p_GaussianSimulatedAnnealingTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((GaussianSimulatedAnnealing *) x));
}
static void *_p_LevenbergMarquardtTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((LevenbergMarquardt *) x));
}
static void *_p_LogNormalSimulatedAnnealingTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((LogNormalSimulatedAnnealing *) x));
}
static void *_p_MirrorGaussianSimulatedAnnealingTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((MirrorGaussianSimulatedAnnealing *) x));
}
static void *_p_SimplexTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((Simplex *) x));
}
static void *_p_SteepestDescentTo_p_OptimizationMethod(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptimizationMethod *)  ((SteepestDescent *) x));
}
static void *_p_BarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((BarrierOption *) x));
}
static void *_p_BasketOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((BasketOption *) x));
}
static void *_p_CdsOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((CdsOption *) x));
}
static void *_p_CliquetOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((CliquetOption *) x));
}
static void *_p_ComplexChooserOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ComplexChooserOption *) x));
}
static void *_p_CompoundOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((CompoundOption *) x));
}
static void *_p_ContinuousAveragingAsianOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ContinuousAveragingAsianOption *) x));
}
static void *_p_ContinuousFixedLookbackOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ContinuousFixedLookbackOption *) x));
}
static void *_p_ContinuousFloatingLookbackOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ContinuousFloatingLookbackOption *) x));
}
static void *_p_ContinuousPartialFixedLookbackOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(ContinuousFixedLookbackOption *) ((ContinuousPartialFixedLookbackOption *) x));
}
static void *_p_ContinuousPartialFloatingLookbackOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(ContinuousFloatingLookbackOption *) ((ContinuousPartialFloatingLookbackOption *) x));
}
static void *_p_DiscreteAveragingAsianOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((DiscreteAveragingAsianOption *) x));
}
static void *_p_DividendBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(BarrierOption *) ((DividendBarrierOption *) x));
}
static void *_p_DividendVanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((DividendVanillaOption *) x));
}
static void *_p_DoubleBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((DoubleBarrierOption *) x));
}
static void *_p_EuropeanOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(VanillaOption *) ((EuropeanOption *) x));
}
static void *_p_EverestOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((EverestOption *) x));
}
static void *_p_ForwardVanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((ForwardVanillaOption *) x));
}
static void *_p_HimalayaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((HimalayaOption *) x));
}
static void *_p_MargrabeOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((MargrabeOption *) x));
}
static void *_p_MultiAssetOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((MultiAssetOption *) x));
}
static void *_p_OneAssetOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((OneAssetOption *) x));
}
static void *_p_PartialTimeBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((PartialTimeBarrierOption *) x));
}
static void *_p_QuantoBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(BarrierOption *) ((QuantoBarrierOption *) x));
}
static void *_p_QuantoDoubleBarrierOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(DoubleBarrierOption *) ((QuantoDoubleBarrierOption *) x));
}
static void *_p_QuantoForwardVanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *)(ForwardVanillaOption *) ((QuantoForwardVanillaOption *) x));
}
static void *_p_QuantoVanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((QuantoVanillaOption *) x));
}
static void *_p_SimpleChooserOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((SimpleChooserOption *) x));
}
static void *_p_SpreadOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (MultiAssetOption *) ((SpreadOption *) x));
}
static void *_p_SwaptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *)  ((Swaption *) x));
}
static void *_p_VanillaOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((VanillaOption *) x));
}
static void *_p_VanillaSwingOptionTo_p_Option(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Option *) (OneAssetOption *) ((VanillaSwingOption *) x));
}
static void *_p_ConstantOptionletVolatilityTo_p_OptionletVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptionletVolatilityStructure *)  ((ConstantOptionletVolatility *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_OptionletVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OptionletVolatilityStructure *)  ((StrippedOptionletAdapter *) x));
}
static void *_p_AoniaTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Aonia *) x));
}
static void *_p_CorraTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Corra *) x));
}
static void *_p_DestrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Destr *) x));
}
static void *_p_EoniaTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Eonia *) x));
}
static void *_p_EstrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Estr *) x));
}
static void *_p_FedFundsTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((FedFunds *) x));
}
static void *_p_NzocrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Nzocr *) x));
}
static void *_p_SofrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Sofr *) x));
}
static void *_p_SoniaTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Sonia *) x));
}
static void *_p_SwestrTo_p_OvernightIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndex *)  ((Swestr *) x));
}
static void *_p_SofrFutureRateHelperTo_p_OvernightIndexFutureRateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((OvernightIndexFutureRateHelper *)  ((SofrFutureRateHelper *) x));
}
static void *_p_ConstantParameterTo_p_Parameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Parameter *)  ((ConstantParameter *) x));
}
static void *_p_NullParameterTo_p_Parameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Parameter *)  ((NullParameter *) x));
}
static void *_p_PiecewiseConstantParameterTo_p_Parameter(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Parameter *)  ((PiecewiseConstantParameter *) x));
}
static void *_p_AssetOrNothingPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((AssetOrNothingPayoff *) x));
}
static void *_p_AverageBasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (BasketPayoff *) ((AverageBasketPayoff *) x));
}
static void *_p_BasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *)  ((BasketPayoff *) x));
}
static void *_p_CashOrNothingPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((CashOrNothingPayoff *) x));
}
static void *_p_FloatingTypePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *) ((FloatingTypePayoff *) x));
}
static void *_p_GapPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((GapPayoff *) x));
}
static void *_p_MaxBasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (BasketPayoff *) ((MaxBasketPayoff *) x));
}
static void *_p_MinBasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (BasketPayoff *) ((MinBasketPayoff *) x));
}
static void *_p_PercentageStrikePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((PercentageStrikePayoff *) x));
}
static void *_p_PlainVanillaPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((PlainVanillaPayoff *) x));
}
static void *_p_SpreadBasketPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (BasketPayoff *) ((SpreadBasketPayoff *) x));
}
static void *_p_StrikedTypePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *) ((StrikedTypePayoff *) x));
}
static void *_p_SuperSharePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((SuperSharePayoff *) x));
}
static void *_p_TypePayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *)  ((TypePayoff *) x));
}
static void *_p_VanillaForwardPayoffTo_p_Payoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Payoff *) (TypePayoff *)(StrikedTypePayoff *) ((VanillaForwardPayoff *) x));
}
static void *_p_ExponentialForwardCorrelationTo_p_PiecewiseConstantCorrelation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PiecewiseConstantCorrelation *)  ((ExponentialForwardCorrelation *) x));
}
static void *_p_AnalyticAmericanMargrabeEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticAmericanMargrabeEngine *) x));
}
static void *_p_AnalyticBSMHullWhiteEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticBSMHullWhiteEngine *) x));
}
static void *_p_AnalyticBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticBarrierEngine *) x));
}
static void *_p_AnalyticBinaryBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticBinaryBarrierEngine *) x));
}
static void *_p_AnalyticCEVEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticCEVEngine *) x));
}
static void *_p_AnalyticCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticCapFloorEngine *) x));
}
static void *_p_AnalyticCliquetEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticCliquetEngine *) x));
}
static void *_p_AnalyticComplexChooserEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticComplexChooserEngine *) x));
}
static void *_p_AnalyticCompoundOptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticCompoundOptionEngine *) x));
}
static void *_p_AnalyticContinuousFixedLookbackEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousFixedLookbackEngine *) x));
}
static void *_p_AnalyticContinuousFloatingLookbackEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousFloatingLookbackEngine *) x));
}
static void *_p_AnalyticContinuousGeometricAveragePriceAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousGeometricAveragePriceAsianEngine *) x));
}
static void *_p_AnalyticContinuousGeometricAveragePriceAsianHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousGeometricAveragePriceAsianHestonEngine *) x));
}
static void *_p_AnalyticContinuousPartialFixedLookbackEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousPartialFixedLookbackEngine *) x));
}
static void *_p_AnalyticContinuousPartialFloatingLookbackEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticContinuousPartialFloatingLookbackEngine *) x));
}
static void *_p_AnalyticDigitalAmericanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDigitalAmericanEngine *) x));
}
static void *_p_AnalyticDigitalAmericanKOEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDigitalAmericanKOEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAveragePriceAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDiscreteGeometricAveragePriceAsianEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAveragePriceAsianHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *) x));
}
static void *_p_AnalyticDiscreteGeometricAverageStrikeAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDiscreteGeometricAverageStrikeAsianEngine *) x));
}
static void *_p_AnalyticDividendEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDividendEuropeanEngine *) x));
}
static void *_p_AnalyticDoubleBarrierBinaryEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDoubleBarrierBinaryEngine *) x));
}
static void *_p_AnalyticDoubleBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticDoubleBarrierEngine *) x));
}
static void *_p_AnalyticEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticEuropeanEngine *) x));
}
static void *_p_AnalyticEuropeanMargrabeEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticEuropeanMargrabeEngine *) x));
}
static void *_p_AnalyticGJRGARCHEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticGJRGARCHEngine *) x));
}
static void *_p_AnalyticH1HWEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticH1HWEngine *) x));
}
static void *_p_AnalyticHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticHestonEngine *) x));
}
static void *_p_AnalyticHestonForwardEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticHestonForwardEuropeanEngine *) x));
}
static void *_p_AnalyticHestonHullWhiteEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticHestonHullWhiteEngine *) x));
}
static void *_p_AnalyticPTDHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticPTDHestonEngine *) x));
}
static void *_p_AnalyticPartialTimeBarrierOptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticPartialTimeBarrierOptionEngine *) x));
}
static void *_p_AnalyticPerformanceEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticPerformanceEngine *) x));
}
static void *_p_AnalyticSimpleChooserEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((AnalyticSimpleChooserEngine *) x));
}
static void *_p_BachelierCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BachelierCapFloorEngine *) x));
}
static void *_p_BachelierSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BachelierSwaptionEngine *) x));
}
static void *_p_BaroneAdesiWhaleyApproximationEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BaroneAdesiWhaleyApproximationEngine *) x));
}
static void *_p_BatesEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BatesEngine *) x));
}
static void *_p_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > *) x));
}
static void *_p_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_BinomialConvertibleEngineT_CoxRossRubinstein_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< CoxRossRubinstein > *) x));
}
static void *_p_BinomialConvertibleEngineT_JarrowRudd_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< JarrowRudd > *) x));
}
static void *_p_BinomialConvertibleEngineT_Joshi4_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< Joshi4 > *) x));
}
static void *_p_BinomialConvertibleEngineT_LeisenReimer_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< LeisenReimer > *) x));
}
static void *_p_BinomialConvertibleEngineT_Tian_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< Tian > *) x));
}
static void *_p_BinomialConvertibleEngineT_Trigeorgis_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialConvertibleEngine< Trigeorgis > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > *) x));
}
static void *_p_BinomialVanillaEngineT_AdditiveEQPBinomialTree_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< AdditiveEQPBinomialTree > *) x));
}
static void *_p_BinomialVanillaEngineT_CoxRossRubinstein_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< CoxRossRubinstein > *) x));
}
static void *_p_BinomialVanillaEngineT_JarrowRudd_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< JarrowRudd > *) x));
}
static void *_p_BinomialVanillaEngineT_Joshi4_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< Joshi4 > *) x));
}
static void *_p_BinomialVanillaEngineT_LeisenReimer_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< LeisenReimer > *) x));
}
static void *_p_BinomialVanillaEngineT_Tian_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< Tian > *) x));
}
static void *_p_BinomialVanillaEngineT_Trigeorgis_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BinomialVanillaEngine< Trigeorgis > *) x));
}
static void *_p_BjerksundStenslandApproximationEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BjerksundStenslandApproximationEngine *) x));
}
static void *_p_BlackCallableFixedRateBondEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BlackCallableFixedRateBondEngine *) x));
}
static void *_p_BlackCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BlackCapFloorEngine *) x));
}
static void *_p_BlackCdsOptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BlackCdsOptionEngine *) x));
}
static void *_p_BlackSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((BlackSwaptionEngine *) x));
}
static void *_p_COSHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((COSHestonEngine *) x));
}
static void *_p_ContinuousArithmeticAsianLevyEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((ContinuousArithmeticAsianLevyEngine *) x));
}
static void *_p_DiscountingBondEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((DiscountingBondEngine *) x));
}
static void *_p_DiscountingSwapEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((DiscountingSwapEngine *) x));
}
static void *_p_ExponentialFittingHestonEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((ExponentialFittingHestonEngine *) x));
}
static void *_p_FFTVarianceGammaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FFTVarianceGammaEngine *) x));
}
static void *_p_Fd2dBlackScholesVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Fd2dBlackScholesVanillaEngine *) x));
}
static void *_p_FdBatesVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBatesVanillaEngine *) x));
}
static void *_p_FdBlackScholesAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesAsianEngine *) x));
}
static void *_p_FdBlackScholesBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesBarrierEngine *) x));
}
static void *_p_FdBlackScholesRebateEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesRebateEngine *) x));
}
static void *_p_FdBlackScholesShoutEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesShoutEngine *) x));
}
static void *_p_FdBlackScholesVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdBlackScholesVanillaEngine *) x));
}
static void *_p_FdCEVVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdCEVVanillaEngine *) x));
}
static void *_p_FdG2SwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdG2SwaptionEngine *) x));
}
static void *_p_FdHestonBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonBarrierEngine *) x));
}
static void *_p_FdHestonDoubleBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonDoubleBarrierEngine *) x));
}
static void *_p_FdHestonHullWhiteVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonHullWhiteVanillaEngine *) x));
}
static void *_p_FdHestonRebateEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonRebateEngine *) x));
}
static void *_p_FdHestonVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHestonVanillaEngine *) x));
}
static void *_p_FdHullWhiteSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdHullWhiteSwaptionEngine *) x));
}
static void *_p_FdOrnsteinUhlenbeckVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdOrnsteinUhlenbeckVanillaEngine *) x));
}
static void *_p_FdSabrVanillaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdSabrVanillaEngine *) x));
}
static void *_p_FdSimpleBSSwingEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdSimpleBSSwingEngine *) x));
}
static void *_p_FdSimpleExtOUJumpSwingEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((FdSimpleExtOUJumpSwingEngine *) x));
}
static void *_p_ForwardEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((ForwardEuropeanEngine *) x));
}
static void *_p_G2SwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((G2SwaptionEngine *) x));
}
static void *_p_Gaussian1dCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dCapFloorEngine *) x));
}
static void *_p_Gaussian1dFloatFloatSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dFloatFloatSwaptionEngine *) x));
}
static void *_p_Gaussian1dJamshidianSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dJamshidianSwaptionEngine *) x));
}
static void *_p_Gaussian1dNonstandardSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dNonstandardSwaptionEngine *) x));
}
static void *_p_Gaussian1dSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((Gaussian1dSwaptionEngine *) x));
}
static void *_p_IntegralCdsEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((IntegralCdsEngine *) x));
}
static void *_p_IntegralEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((IntegralEngine *) x));
}
static void *_p_IsdaCdsEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((IsdaCdsEngine *) x));
}
static void *_p_JamshidianSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((JamshidianSwaptionEngine *) x));
}
static void *_p_JuQuadraticApproximationEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((JuQuadraticApproximationEngine *) x));
}
static void *_p_KirkEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((KirkEngine *) x));
}
static void *_p_KirkSpreadOptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((KirkSpreadOptionEngine *) x));
}
static void *_p_MCAmericanBasketEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanBasketEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCAmericanEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCAmericanEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCAmericanEngine< PseudoRandom > *) x));
}
static void *_p_MCBarrierEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCBarrierEngine< LowDiscrepancy > *) x));
}
static void *_p_MCBarrierEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCBarrierEngine< PseudoRandom > *) x));
}
static void *_p_MCDigitalEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDigitalEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDigitalEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDigitalEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticAPEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticAPEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticAPHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticASEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteArithmeticASEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteArithmeticASEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteGeometricAPEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteGeometricAPEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteGeometricAPEngine< PseudoRandom > *) x));
}
static void *_p_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCDiscreteGeometricAPHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanBasketEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanBasketEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanBasketEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanBasketEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanGJRGARCHEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanGJRGARCHEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanGJRGARCHEngine< PseudoRandom > *) x));
}
static void *_p_MCEuropeanHestonEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEuropeanHestonEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEuropeanHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCEverestEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEverestEngine< LowDiscrepancy > *) x));
}
static void *_p_MCEverestEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCEverestEngine< PseudoRandom > *) x));
}
static void *_p_MCForwardEuropeanBSEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCForwardEuropeanBSEngine< LowDiscrepancy > *) x));
}
static void *_p_MCForwardEuropeanBSEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCForwardEuropeanBSEngine< PseudoRandom > *) x));
}
static void *_p_MCForwardEuropeanHestonEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCForwardEuropeanHestonEngine< LowDiscrepancy > *) x));
}
static void *_p_MCForwardEuropeanHestonEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCForwardEuropeanHestonEngine< PseudoRandom > *) x));
}
static void *_p_MCHimalayaEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCHimalayaEngine< LowDiscrepancy > *) x));
}
static void *_p_MCHimalayaEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCHimalayaEngine< PseudoRandom > *) x));
}
static void *_p_MCPerformanceEngineT_LowDiscrepancy_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCPerformanceEngine< LowDiscrepancy > *) x));
}
static void *_p_MCPerformanceEngineT_PseudoRandom_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MCPerformanceEngine< PseudoRandom > *) x));
}
static void *_p_MidPointCdsEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((MidPointCdsEngine *) x));
}
static void *_p_QdFpAmericanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QdFpAmericanEngine *) x));
}
static void *_p_QdPlusAmericanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QdPlusAmericanEngine *) x));
}
static void *_p_QuantoBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QuantoBarrierEngine *) x));
}
static void *_p_QuantoEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QuantoEuropeanEngine *) x));
}
static void *_p_QuantoForwardEuropeanEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((QuantoForwardEuropeanEngine *) x));
}
static void *_p_RiskyBondEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((RiskyBondEngine *) x));
}
static void *_p_StulzEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((StulzEngine *) x));
}
static void *_p_SuoWangDoubleBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((SuoWangDoubleBarrierEngine *) x));
}
static void *_p_TreeCallableFixedRateBondEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TreeCallableFixedRateBondEngine *) x));
}
static void *_p_TreeCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TreeCapFloorEngine *) x));
}
static void *_p_TreeSwaptionEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TreeSwaptionEngine *) x));
}
static void *_p_TurnbullWakemanAsianEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((TurnbullWakemanAsianEngine *) x));
}
static void *_p_VannaVolgaBarrierEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VannaVolgaBarrierEngine *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > *) x));
}
static void *_p_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_tTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > *) x));
}
static void *_p_VarianceGammaEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((VarianceGammaEngine *) x));
}
static void *_p_YoYInflationBachelierCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((YoYInflationBachelierCapFloorEngine *) x));
}
static void *_p_YoYInflationBlackCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((YoYInflationBlackCapFloorEngine *) x));
}
static void *_p_YoYInflationUnitDisplacedBlackCapFloorEngineTo_p_PricingEngine(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((PricingEngine *)  ((YoYInflationUnitDisplacedBlackCapFloorEngine *) x));
}
static void *_p_QdFpLegendreSchemeTo_p_QdFpIterationScheme(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((QdFpIterationScheme *)  ((QdFpLegendreScheme *) x));
}
static void *_p_QdFpLegendreTanhSinhSchemeTo_p_QdFpIterationScheme(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((QdFpIterationScheme *) (QdFpLegendreScheme *) ((QdFpLegendreTanhSinhScheme *) x));
}
static void *_p_QdFpTanhSinhIterationSchemeTo_p_QdFpIterationScheme(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((QdFpIterationScheme *)  ((QdFpTanhSinhIterationScheme *) x));
}
static void *_p_QdFpLegendreTanhSinhSchemeTo_p_QdFpLegendreScheme(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((QdFpLegendreScheme *)  ((QdFpLegendreTanhSinhScheme *) x));
}
static void *_p_CompositeQuoteT_BinaryFunction_tTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((CompositeQuote< BinaryFunction > *) x));
}
static void *_p_DeltaVolQuoteTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((DeltaVolQuote *) x));
}
static void *_p_DerivedQuoteT_UnaryFunction_tTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((DerivedQuote< UnaryFunction > *) x));
}
static void *_p_LastFixingQuoteTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((LastFixingQuote *) x));
}
static void *_p_SimpleQuoteTo_p_Quote(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Quote *)  ((SimpleQuote *) x));
}
static void *_p_ArithmeticOISRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((ArithmeticOISRateHelper *) x));
}
static void *_p_BondHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((BondHelper *) x));
}
static void *_p_ConstNotionalCrossCurrencyBasisSwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((ConstNotionalCrossCurrencyBasisSwapRateHelper *) x));
}
static void *_p_DatedOISRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((DatedOISRateHelper *) x));
}
static void *_p_DepositRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((DepositRateHelper *) x));
}
static void *_p_FixedRateBondHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *) (BondHelper *) ((FixedRateBondHelper *) x));
}
static void *_p_FraRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((FraRateHelper *) x));
}
static void *_p_FuturesRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((FuturesRateHelper *) x));
}
static void *_p_FxSwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((FxSwapRateHelper *) x));
}
static void *_p_IborIborBasisSwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((IborIborBasisSwapRateHelper *) x));
}
static void *_p_MtMCrossCurrencyBasisSwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((MtMCrossCurrencyBasisSwapRateHelper *) x));
}
static void *_p_OISRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((OISRateHelper *) x));
}
static void *_p_OvernightIborBasisSwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((OvernightIborBasisSwapRateHelper *) x));
}
static void *_p_OvernightIndexFutureRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((OvernightIndexFutureRateHelper *) x));
}
static void *_p_SofrFutureRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *) (OvernightIndexFutureRateHelper *) ((SofrFutureRateHelper *) x));
}
static void *_p_SwapRateHelperTo_p_RateHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RateHelper *)  ((SwapRateHelper *) x));
}
static void *_p_CustomRegionTo_p_Region(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Region *)  ((CustomRegion *) x));
}
static void *_p_BSMRNDCalculatorTo_p_RiskNeutralDensityCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RiskNeutralDensityCalculator *)  ((BSMRNDCalculator *) x));
}
static void *_p_CEVRNDCalculatorTo_p_RiskNeutralDensityCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RiskNeutralDensityCalculator *)  ((CEVRNDCalculator *) x));
}
static void *_p_GBSMRNDCalculatorTo_p_RiskNeutralDensityCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RiskNeutralDensityCalculator *)  ((GBSMRNDCalculator *) x));
}
static void *_p_HestonRNDCalculatorTo_p_RiskNeutralDensityCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RiskNeutralDensityCalculator *)  ((HestonRNDCalculator *) x));
}
static void *_p_LocalVolRNDCalculatorTo_p_RiskNeutralDensityCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RiskNeutralDensityCalculator *)  ((LocalVolRNDCalculator *) x));
}
static void *_p_SquareRootProcessRNDCalculatorTo_p_RiskNeutralDensityCalculator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((RiskNeutralDensityCalculator *)  ((SquareRootProcessRNDCalculator *) x));
}
static void *_p_CeilingTruncationTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((CeilingTruncation *) x));
}
static void *_p_ClosestRoundingTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((ClosestRounding *) x));
}
static void *_p_DownRoundingTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((DownRounding *) x));
}
static void *_p_FloorTruncationTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((FloorTruncation *) x));
}
static void *_p_UpRoundingTo_p_Rounding(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Rounding *)  ((UpRounding *) x));
}
static void *_p_KerkhofSeasonalityTo_p_Seasonality(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Seasonality *)  ((KerkhofSeasonality *) x));
}
static void *_p_MultiplicativePriceSeasonalityTo_p_Seasonality(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Seasonality *)  ((MultiplicativePriceSeasonality *) x));
}
static void *_p_BlackKarasinskiTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((BlackKarasinski *) x));
}
static void *_p_CoxIngersollRossTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((CoxIngersollRoss *) x));
}
static void *_p_ExtendedCoxIngersollRossTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((ExtendedCoxIngersollRoss *) x));
}
static void *_p_G2To_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((G2 *) x));
}
static void *_p_HullWhiteTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *) (OneFactorAffineModel *)(Vasicek *) ((HullWhite *) x));
}
static void *_p_OneFactorAffineModelTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *)  ((OneFactorAffineModel *) x));
}
static void *_p_VasicekTo_p_ShortRateModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ShortRateModel *) (OneFactorAffineModel *) ((Vasicek *) x));
}
static void *_p_FlatSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((FlatSmileSection *) x));
}
static void *_p_InterpolatedSmileSectionT_Cubic_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< Cubic > *) x));
}
static void *_p_InterpolatedSmileSectionT_Linear_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< Linear > *) x));
}
static void *_p_InterpolatedSmileSectionT_MonotonicCubic_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< MonotonicCubic > *) x));
}
static void *_p_InterpolatedSmileSectionT_SplineCubic_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((InterpolatedSmileSection< SplineCubic > *) x));
}
static void *_p_KahaleSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((KahaleSmileSection *) x));
}
static void *_p_NoArbSabrInterpolatedSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((NoArbSabrInterpolatedSmileSection *) x));
}
static void *_p_NoArbSabrSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((NoArbSabrSmileSection *) x));
}
static void *_p_SabrSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((SabrSmileSection *) x));
}
static void *_p_SviInterpolatedSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((SviInterpolatedSmileSection *) x));
}
static void *_p_SviSmileSectionTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((SviSmileSection *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrFullFd_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrInterpolatedSmileSection< ZabrFullFd > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrInterpolatedSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrFullFd_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrFullFd > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrLocalVolatility_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrLocalVolatility > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityLognormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrShortMaturityLognormal > *) x));
}
static void *_p_ZabrSmileSectionT_ZabrShortMaturityNormal_tTo_p_SmileSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SmileSection *)  ((ZabrSmileSection< ZabrShortMaturityNormal > *) x));
}
static void *_p_RiskStatisticsTo_p_Statistics(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Statistics *)  ((RiskStatistics *) x));
}
static void *_p_FdmAmericanStepConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmAmericanStepCondition *) x));
}
static void *_p_FdmArithmeticAverageConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmArithmeticAverageCondition *) x));
}
static void *_p_FdmBermudanStepConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmBermudanStepCondition *) x));
}
static void *_p_FdmDividendHandlerTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmDividendHandler *) x));
}
static void *_p_FdmSimpleStorageConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmSimpleStorageCondition *) x));
}
static void *_p_FdmSimpleSwingConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmSimpleSwingCondition *) x));
}
static void *_p_FdmSnapshotConditionTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmSnapshotCondition *) x));
}
static void *_p_FdmStepConditionCompositeTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmStepConditionComposite *) x));
}
static void *_p_FdmStepConditionProxyTo_p_StepConditionT_Array_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StepCondition< Array > *)  ((FdmStepConditionProxy *) x));
}
static void *_p_BatesProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (HestonProcess *) ((BatesProcess *) x));
}
static void *_p_BlackProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((BlackProcess *) x));
}
static void *_p_BlackScholesMertonProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((BlackScholesMertonProcess *) x));
}
static void *_p_BlackScholesProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((BlackScholesProcess *) x));
}
static void *_p_ExtOUWithJumpsProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((ExtOUWithJumpsProcess *) x));
}
static void *_p_ExtendedOrnsteinUhlenbeckProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((ExtendedOrnsteinUhlenbeckProcess *) x));
}
static void *_p_G2ForwardProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((G2ForwardProcess *) x));
}
static void *_p_G2ProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((G2Process *) x));
}
static void *_p_GJRGARCHProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((GJRGARCHProcess *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *)(GeneralizedBlackScholesProcess *) ((GarmanKohlagenProcess *) x));
}
static void *_p_GeneralizedBlackScholesProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((GeneralizedBlackScholesProcess *) x));
}
static void *_p_GeometricBrownianMotionProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((GeometricBrownianMotionProcess *) x));
}
static void *_p_GsrProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((GsrProcess *) x));
}
static void *_p_HestonProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((HestonProcess *) x));
}
static void *_p_HestonSLVProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((HestonSLVProcess *) x));
}
static void *_p_HullWhiteForwardProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((HullWhiteForwardProcess *) x));
}
static void *_p_HullWhiteProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((HullWhiteProcess *) x));
}
static void *_p_KlugeExtOUProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((KlugeExtOUProcess *) x));
}
static void *_p_Merton76ProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((Merton76Process *) x));
}
static void *_p_OrnsteinUhlenbeckProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((OrnsteinUhlenbeckProcess *) x));
}
static void *_p_StochasticProcess1DTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((StochasticProcess1D *) x));
}
static void *_p_StochasticProcessArrayTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *)  ((StochasticProcessArray *) x));
}
static void *_p_VarianceGammaProcessTo_p_StochasticProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess *) (StochasticProcess1D *) ((VarianceGammaProcess *) x));
}
static void *_p_BlackProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((BlackProcess *) x));
}
static void *_p_BlackScholesMertonProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((BlackScholesMertonProcess *) x));
}
static void *_p_BlackScholesProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((BlackScholesProcess *) x));
}
static void *_p_ExtendedOrnsteinUhlenbeckProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((ExtendedOrnsteinUhlenbeckProcess *) x));
}
static void *_p_GarmanKohlagenProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *) (GeneralizedBlackScholesProcess *) ((GarmanKohlagenProcess *) x));
}
static void *_p_GeneralizedBlackScholesProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((GeneralizedBlackScholesProcess *) x));
}
static void *_p_GeometricBrownianMotionProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((GeometricBrownianMotionProcess *) x));
}
static void *_p_GsrProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((GsrProcess *) x));
}
static void *_p_HullWhiteForwardProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((HullWhiteForwardProcess *) x));
}
static void *_p_HullWhiteProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((HullWhiteProcess *) x));
}
static void *_p_Merton76ProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((Merton76Process *) x));
}
static void *_p_OrnsteinUhlenbeckProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((OrnsteinUhlenbeckProcess *) x));
}
static void *_p_VarianceGammaProcessTo_p_StochasticProcess1D(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StochasticProcess1D *)  ((VarianceGammaProcess *) x));
}
static void *_p_AssetOrNothingPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((AssetOrNothingPayoff *) x));
}
static void *_p_CashOrNothingPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((CashOrNothingPayoff *) x));
}
static void *_p_GapPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((GapPayoff *) x));
}
static void *_p_PercentageStrikePayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((PercentageStrikePayoff *) x));
}
static void *_p_PlainVanillaPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((PlainVanillaPayoff *) x));
}
static void *_p_SuperSharePayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((SuperSharePayoff *) x));
}
static void *_p_VanillaForwardPayoffTo_p_StrikedTypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrikedTypePayoff *)  ((VanillaForwardPayoff *) x));
}
static void *_p_OptionletStripper1To_p_StrippedOptionletBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrippedOptionletBase *)  ((OptionletStripper1 *) x));
}
static void *_p_StrippedOptionletTo_p_StrippedOptionletBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((StrippedOptionletBase *)  ((StrippedOptionlet *) x));
}
static void *_p_AveragingRatePricerTo_p_SubPeriodsPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SubPeriodsPricer *)  ((AveragingRatePricer *) x));
}
static void *_p_CompoundingRatePricerTo_p_SubPeriodsPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SubPeriodsPricer *)  ((CompoundingRatePricer *) x));
}
static void *_p_ArithmeticAverageOISTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((ArithmeticAverageOIS *) x));
}
static void *_p_AssetSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((AssetSwap *) x));
}
static void *_p_CPISwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((CPISwap *) x));
}
static void *_p_EquityTotalReturnSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((EquityTotalReturnSwap *) x));
}
static void *_p_FloatFloatSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((FloatFloatSwap *) x));
}
static void *_p_NonstandardSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((NonstandardSwap *) x));
}
static void *_p_OvernightIndexedSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((OvernightIndexedSwap *) x));
}
static void *_p_VanillaSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((VanillaSwap *) x));
}
static void *_p_YearOnYearInflationSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((YearOnYearInflationSwap *) x));
}
static void *_p_ZeroCouponInflationSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((ZeroCouponInflationSwap *) x));
}
static void *_p_ZeroCouponSwapTo_p_Swap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Swap *)  ((ZeroCouponSwap *) x));
}
static void *_p_ChfLiborSwapIsdaFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((ChfLiborSwapIsdaFix *) x));
}
static void *_p_EurLiborSwapIfrFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EurLiborSwapIfrFix *) x));
}
static void *_p_EurLiborSwapIsdaFixATo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EurLiborSwapIsdaFixA *) x));
}
static void *_p_EurLiborSwapIsdaFixBTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EurLiborSwapIsdaFixB *) x));
}
static void *_p_EuriborSwapIfrFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EuriborSwapIfrFix *) x));
}
static void *_p_EuriborSwapIsdaFixATo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EuriborSwapIsdaFixA *) x));
}
static void *_p_EuriborSwapIsdaFixBTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((EuriborSwapIsdaFixB *) x));
}
static void *_p_GbpLiborSwapIsdaFixTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((GbpLiborSwapIsdaFix *) x));
}
static void *_p_JpyLiborSwapIsdaFixAmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((JpyLiborSwapIsdaFixAm *) x));
}
static void *_p_JpyLiborSwapIsdaFixPmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((JpyLiborSwapIsdaFixPm *) x));
}
static void *_p_OvernightIndexedSwapIndexTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((OvernightIndexedSwapIndex *) x));
}
static void *_p_UsdLiborSwapIsdaFixAmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((UsdLiborSwapIsdaFixAm *) x));
}
static void *_p_UsdLiborSwapIsdaFixPmTo_p_SwapIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwapIndex *)  ((UsdLiborSwapIsdaFixPm *) x));
}
static void *_p_InterpolatedSwaptionVolatilityCubeTo_p_SwaptionVolatilityCube(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityCube *)  ((InterpolatedSwaptionVolatilityCube *) x));
}
static void *_p_SabrSwaptionVolatilityCubeTo_p_SwaptionVolatilityCube(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityCube *)  ((SabrSwaptionVolatilityCube *) x));
}
static void *_p_InterpolatedSwaptionVolatilityCubeTo_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *) (SwaptionVolatilityCube *) ((InterpolatedSwaptionVolatilityCube *) x));
}
static void *_p_SabrSwaptionVolatilityCubeTo_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *) (SwaptionVolatilityCube *) ((SabrSwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *)  ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_SwaptionVolatilityDiscrete(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityDiscrete *)  ((SwaptionVolatilityMatrix *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *)  ((ConstantSwaptionVolatility *) x));
}
static void *_p_InterpolatedSwaptionVolatilityCubeTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((InterpolatedSwaptionVolatilityCube *) x));
}
static void *_p_SabrSwaptionVolatilityCubeTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SabrSwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *)  ((SwaptionVolatilityDiscrete *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_SwaptionVolatilityStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((SwaptionVolatilityStructure *) (SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_AndreasenHugeLocalVolAdapterTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((AndreasenHugeLocalVolAdapter *) x));
}
static void *_p_AndreasenHugeVolatilityAdapterTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((AndreasenHugeVolatilityAdapter *) x));
}
static void *_p_BlackConstantVolTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackConstantVol *) x));
}
static void *_p_BlackVarianceCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceCurve *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((BlackVarianceSurface *) x));
}
static void *_p_BlackVolTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((BlackVolTermStructure *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolCurve *) x));
}
static void *_p_CapFloorTermVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(CapFloorTermVolatilityStructure *) ((CapFloorTermVolSurface *) x));
}
static void *_p_CapFloorTermVolatilityStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((CapFloorTermVolatilityStructure *) x));
}
static void *_p_CompositeZeroYieldStructureT_BinaryFunction_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((CompositeZeroYieldStructure< BinaryFunction > *) x));
}
static void *_p_ConstantOptionletVolatilityTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(OptionletVolatilityStructure *) ((ConstantOptionletVolatility *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((ConstantSwaptionVolatility *) x));
}
static void *_p_ConstantYoYOptionletVolatilityTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_DefaultProbabilityTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((DefaultProbabilityTermStructure *) x));
}
static void *_p_FittedBondDiscountCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((FittedBondDiscountCurve *) x));
}
static void *_p_FixedLocalVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((FixedLocalVolSurface *) x));
}
static void *_p_FlatForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((FlatForward *) x));
}
static void *_p_FlatHazardRateTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((FlatHazardRate *) x));
}
static void *_p_ForwardSpreadedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((ForwardSpreadedTermStructure *) x));
}
static void *_p_GlobalLinearSimpleZeroCurveTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((GlobalLinearSimpleZeroCurve *) x));
}
static void *_p_GridModelLocalVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((GridModelLocalVolSurface *) x));
}
static void *_p_HestonBlackVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(BlackVolTermStructure *) ((HestonBlackVolSurface *) x));
}
static void *_p_ImpliedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((ImpliedTermStructure *) x));
}
static void *_p_InflationTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((InflationTermStructure *) x));
}
static void *_p_InterpolatedDefaultDensityCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((InterpolatedDefaultDensityCurve< Linear > *) x));
}
static void *_p_InterpolatedDiscountCurveT_KrugerLog_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< KrugerLog > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogLinear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< LogLinear > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogMixedLinearCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< LogMixedLinearCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_MonotonicLogCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< MonotonicLogCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_SplineCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< SplineCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_SplineLogCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedDiscountCurve< SplineLogCubic > *) x));
}
static void *_p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedForwardCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedHazardRateCurveT_BackwardFlat_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((InterpolatedHazardRateCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedSurvivalProbabilityCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((InterpolatedSurvivalProbabilityCurve< Linear > *) x));
}
static void *_p_InterpolatedSwaptionVolatilityCubeTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((InterpolatedSwaptionVolatilityCube *) x));
}
static void *_p_InterpolatedYoYInflationCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *)(YoYInflationTermStructure *) ((InterpolatedYoYInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((InterpolatedYoYOptionletVolatilityCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroCurveT_Cubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< Cubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< DefaultLogCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_Kruger_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< Kruger > *) x));
}
static void *_p_InterpolatedZeroCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroCurveT_LogLinear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< LogLinear > *) x));
}
static void *_p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< MonotonicCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_SplineCubic_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((InterpolatedZeroCurve< SplineCubic > *) x));
}
static void *_p_InterpolatedZeroInflationCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *)(ZeroInflationTermStructure *) ((InterpolatedZeroInflationCurve< Linear > *) x));
}
static void *_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(YoYOptionletVolatilitySurface *) ((KInterpolatedYoYOptionletVolatilitySurface< Linear > *) x));
}
static void *_p_LocalConstantVolTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalConstantVol *) x));
}
static void *_p_LocalVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *) ((LocalVolSurface *) x));
}
static void *_p_LocalVolTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((LocalVolTermStructure *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(LocalVolTermStructure *)(LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_OptionletVolatilityStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((OptionletVolatilityStructure *) x));
}
static void *_p_PiecewiseConvexMonotoneForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseConvexMonotoneForward *) x));
}
static void *_p_PiecewiseConvexMonotoneZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseConvexMonotoneZero *) x));
}
static void *_p_PiecewiseCubicZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseCubicZero *) x));
}
static void *_p_PiecewiseFlatForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseFlatForward *) x));
}
static void *_p_PiecewiseFlatHazardRateTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (DefaultProbabilityTermStructure *) ((PiecewiseFlatHazardRate *) x));
}
static void *_p_PiecewiseKrugerLogDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseKrugerLogDiscount *) x));
}
static void *_p_PiecewiseKrugerZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseKrugerZero *) x));
}
static void *_p_PiecewiseLinearForwardTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLinearForward *) x));
}
static void *_p_PiecewiseLinearZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLinearZero *) x));
}
static void *_p_PiecewiseLogCubicDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLogCubicDiscount *) x));
}
static void *_p_PiecewiseLogLinearDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLogLinearDiscount *) x));
}
static void *_p_PiecewiseLogMixedLinearCubicDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseLogMixedLinearCubicDiscount *) x));
}
static void *_p_PiecewiseNaturalCubicZeroTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseNaturalCubicZero *) x));
}
static void *_p_PiecewiseNaturalLogCubicDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseNaturalLogCubicDiscount *) x));
}
static void *_p_PiecewiseSplineCubicDiscountTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseSplineCubicDiscount *) x));
}
static void *_p_PiecewiseYoYInflationCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *)(YoYInflationTermStructure *) ((PiecewiseYoYInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseZeroInflationCurveT_Linear_tTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *)(ZeroInflationTermStructure *) ((PiecewiseZeroInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseZeroSpreadedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((PiecewiseZeroSpreadedTermStructure *) x));
}
static void *_p_QuantoTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((QuantoTermStructure *) x));
}
static void *_p_SabrSwaptionVolatilityCubeTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SabrSwaptionVolatilityCube *) x));
}
static void *_p_SpreadedBackwardFlatZeroInterpolatedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((SpreadedBackwardFlatZeroInterpolatedTermStructure *) x));
}
static void *_p_SpreadedLinearZeroInterpolatedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((SpreadedLinearZeroInterpolatedTermStructure *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(OptionletVolatilityStructure *) ((StrippedOptionletAdapter *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *) ((SwaptionVolatilityDiscrete *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *)(SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_SwaptionVolatilityStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((SwaptionVolatilityStructure *) x));
}
static void *_p_UltimateForwardTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((UltimateForwardTermStructure *) x));
}
static void *_p_VolatilityTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((VolatilityTermStructure *) x));
}
static void *_p_YieldTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *)  ((YieldTermStructure *) x));
}
static void *_p_YoYCapFloorTermPriceSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *) ((YoYCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationCapFloorTermPriceSurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *)(YoYCapFloorTermPriceSurface *) ((YoYInflationCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *) ((YoYInflationTermStructure *) x));
}
static void *_p_YoYOptionletVolatilitySurfaceTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (VolatilityTermStructure *) ((YoYOptionletVolatilitySurface *) x));
}
static void *_p_ZeroInflationTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (InflationTermStructure *) ((ZeroInflationTermStructure *) x));
}
static void *_p_ZeroSpreadedTermStructureTo_p_TermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructure *) (YieldTermStructure *) ((ZeroSpreadedTermStructure *) x));
}
static void *_p_Gaussian1dModelTo_p_TermStructureConsistentModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructureConsistentModel *)  ((Gaussian1dModel *) x));
}
static void *_p_GsrTo_p_TermStructureConsistentModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructureConsistentModel *) (Gaussian1dModel *) ((Gsr *) x));
}
static void *_p_MarkovFunctionalTo_p_TermStructureConsistentModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TermStructureConsistentModel *) (Gaussian1dModel *) ((MarkovFunctional *) x));
}
static void *_p_DMinusTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DMinus *) x));
}
static void *_p_DPlusTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DPlus *) x));
}
static void *_p_DPlusDMinusTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DPlusDMinus *) x));
}
static void *_p_DZeroTo_p_TridiagonalOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TridiagonalOperator *)  ((DZero *) x));
}
static void *_p_FirstDerivativeOpTo_p_TripleBandLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TripleBandLinearOp *)  ((FirstDerivativeOp *) x));
}
static void *_p_SecondDerivativeOpTo_p_TripleBandLinearOp(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TripleBandLinearOp *)  ((SecondDerivativeOp *) x));
}
static void *_p_AssetOrNothingPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((AssetOrNothingPayoff *) x));
}
static void *_p_CashOrNothingPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((CashOrNothingPayoff *) x));
}
static void *_p_FloatingTypePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *)  ((FloatingTypePayoff *) x));
}
static void *_p_GapPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((GapPayoff *) x));
}
static void *_p_PercentageStrikePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((PercentageStrikePayoff *) x));
}
static void *_p_PlainVanillaPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((PlainVanillaPayoff *) x));
}
static void *_p_StrikedTypePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *)  ((StrikedTypePayoff *) x));
}
static void *_p_SuperSharePayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((SuperSharePayoff *) x));
}
static void *_p_VanillaForwardPayoffTo_p_TypePayoff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((TypePayoff *) (StrikedTypePayoff *) ((VanillaForwardPayoff *) x));
}
static void *_p_EuropeanOptionTo_p_VanillaOption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VanillaOption *)  ((EuropeanOption *) x));
}
static void *_p_HullWhiteTo_p_Vasicek(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Vasicek *)  ((HullWhite *) x));
}
static void *_p_AndreasenHugeLocalVolAdapterTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((AndreasenHugeLocalVolAdapter *) x));
}
static void *_p_AndreasenHugeVolatilityAdapterTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((AndreasenHugeVolatilityAdapter *) x));
}
static void *_p_BlackConstantVolTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((BlackConstantVol *) x));
}
static void *_p_BlackVarianceCurveTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((BlackVarianceCurve *) x));
}
static void *_p_BlackVarianceSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((BlackVarianceSurface *) x));
}
static void *_p_BlackVolTermStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((BlackVolTermStructure *) x));
}
static void *_p_CapFloorTermVolCurveTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (CapFloorTermVolatilityStructure *) ((CapFloorTermVolCurve *) x));
}
static void *_p_CapFloorTermVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (CapFloorTermVolatilityStructure *) ((CapFloorTermVolSurface *) x));
}
static void *_p_CapFloorTermVolatilityStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((CapFloorTermVolatilityStructure *) x));
}
static void *_p_ConstantOptionletVolatilityTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (OptionletVolatilityStructure *) ((ConstantOptionletVolatility *) x));
}
static void *_p_ConstantSwaptionVolatilityTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *) ((ConstantSwaptionVolatility *) x));
}
static void *_p_ConstantYoYOptionletVolatilityTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (YoYOptionletVolatilitySurface *) ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_FixedLocalVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((FixedLocalVolSurface *) x));
}
static void *_p_GridModelLocalVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((GridModelLocalVolSurface *) x));
}
static void *_p_HestonBlackVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (BlackVolTermStructure *) ((HestonBlackVolSurface *) x));
}
static void *_p_InterpolatedSwaptionVolatilityCubeTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((InterpolatedSwaptionVolatilityCube *) x));
}
static void *_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (YoYOptionletVolatilitySurface *) ((InterpolatedYoYOptionletVolatilityCurve< Linear > *) x));
}
static void *_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (YoYOptionletVolatilitySurface *) ((KInterpolatedYoYOptionletVolatilitySurface< Linear > *) x));
}
static void *_p_LocalConstantVolTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((LocalConstantVol *) x));
}
static void *_p_LocalVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *) ((LocalVolSurface *) x));
}
static void *_p_LocalVolTermStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((LocalVolTermStructure *) x));
}
static void *_p_NoExceptLocalVolSurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (LocalVolTermStructure *)(LocalVolSurface *) ((NoExceptLocalVolSurface *) x));
}
static void *_p_OptionletVolatilityStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((OptionletVolatilityStructure *) x));
}
static void *_p_SabrSwaptionVolatilityCubeTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *)(SwaptionVolatilityCube *) ((SabrSwaptionVolatilityCube *) x));
}
static void *_p_StrippedOptionletAdapterTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (OptionletVolatilityStructure *) ((StrippedOptionletAdapter *) x));
}
static void *_p_SwaptionVolatilityCubeTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityCube *) x));
}
static void *_p_SwaptionVolatilityDiscreteTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *) ((SwaptionVolatilityDiscrete *) x));
}
static void *_p_SwaptionVolatilityMatrixTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *) (SwaptionVolatilityStructure *)(SwaptionVolatilityDiscrete *) ((SwaptionVolatilityMatrix *) x));
}
static void *_p_SwaptionVolatilityStructureTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((SwaptionVolatilityStructure *) x));
}
static void *_p_YoYOptionletVolatilitySurfaceTo_p_VolatilityTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((VolatilityTermStructure *)  ((YoYOptionletVolatilitySurface *) x));
}
static void *_p_CompositeZeroYieldStructureT_BinaryFunction_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((CompositeZeroYieldStructure< BinaryFunction > *) x));
}
static void *_p_FittedBondDiscountCurveTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((FittedBondDiscountCurve *) x));
}
static void *_p_FlatForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((FlatForward *) x));
}
static void *_p_ForwardSpreadedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((ForwardSpreadedTermStructure *) x));
}
static void *_p_GlobalLinearSimpleZeroCurveTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((GlobalLinearSimpleZeroCurve *) x));
}
static void *_p_ImpliedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((ImpliedTermStructure *) x));
}
static void *_p_InterpolatedDiscountCurveT_KrugerLog_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< KrugerLog > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogLinear_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< LogLinear > *) x));
}
static void *_p_InterpolatedDiscountCurveT_LogMixedLinearCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< LogMixedLinearCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_MonotonicLogCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< MonotonicLogCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_SplineCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< SplineCubic > *) x));
}
static void *_p_InterpolatedDiscountCurveT_SplineLogCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedDiscountCurve< SplineLogCubic > *) x));
}
static void *_p_InterpolatedForwardCurveT_BackwardFlat_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedForwardCurve< BackwardFlat > *) x));
}
static void *_p_InterpolatedZeroCurveT_Cubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< Cubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_DefaultLogCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< DefaultLogCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_Kruger_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< Kruger > *) x));
}
static void *_p_InterpolatedZeroCurveT_Linear_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< Linear > *) x));
}
static void *_p_InterpolatedZeroCurveT_LogLinear_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< LogLinear > *) x));
}
static void *_p_InterpolatedZeroCurveT_MonotonicCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< MonotonicCubic > *) x));
}
static void *_p_InterpolatedZeroCurveT_SplineCubic_tTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((InterpolatedZeroCurve< SplineCubic > *) x));
}
static void *_p_PiecewiseConvexMonotoneForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseConvexMonotoneForward *) x));
}
static void *_p_PiecewiseConvexMonotoneZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseConvexMonotoneZero *) x));
}
static void *_p_PiecewiseCubicZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseCubicZero *) x));
}
static void *_p_PiecewiseFlatForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseFlatForward *) x));
}
static void *_p_PiecewiseKrugerLogDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseKrugerLogDiscount *) x));
}
static void *_p_PiecewiseKrugerZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseKrugerZero *) x));
}
static void *_p_PiecewiseLinearForwardTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLinearForward *) x));
}
static void *_p_PiecewiseLinearZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLinearZero *) x));
}
static void *_p_PiecewiseLogCubicDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLogCubicDiscount *) x));
}
static void *_p_PiecewiseLogLinearDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLogLinearDiscount *) x));
}
static void *_p_PiecewiseLogMixedLinearCubicDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseLogMixedLinearCubicDiscount *) x));
}
static void *_p_PiecewiseNaturalCubicZeroTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseNaturalCubicZero *) x));
}
static void *_p_PiecewiseNaturalLogCubicDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseNaturalLogCubicDiscount *) x));
}
static void *_p_PiecewiseSplineCubicDiscountTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseSplineCubicDiscount *) x));
}
static void *_p_PiecewiseZeroSpreadedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((PiecewiseZeroSpreadedTermStructure *) x));
}
static void *_p_QuantoTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((QuantoTermStructure *) x));
}
static void *_p_SpreadedBackwardFlatZeroInterpolatedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((SpreadedBackwardFlatZeroInterpolatedTermStructure *) x));
}
static void *_p_SpreadedLinearZeroInterpolatedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((SpreadedLinearZeroInterpolatedTermStructure *) x));
}
static void *_p_UltimateForwardTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((UltimateForwardTermStructure *) x));
}
static void *_p_ZeroSpreadedTermStructureTo_p_YieldTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YieldTermStructure *)  ((ZeroSpreadedTermStructure *) x));
}
static void *_p_YoYInflationCapFloorTermPriceSurfaceTo_p_YoYCapFloorTermPriceSurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYCapFloorTermPriceSurface *)  ((YoYInflationCapFloorTermPriceSurface *) x));
}
static void *_p_YoYInflationCapTo_p_YoYInflationCapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCapFloor *)  ((YoYInflationCap *) x));
}
static void *_p_YoYInflationCollarTo_p_YoYInflationCapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCapFloor *)  ((YoYInflationCollar *) x));
}
static void *_p_YoYInflationFloorTo_p_YoYInflationCapFloor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCapFloor *)  ((YoYInflationFloor *) x));
}
static void *_p_CappedFlooredYoYInflationCouponTo_p_YoYInflationCoupon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCoupon *)  ((CappedFlooredYoYInflationCoupon *) x));
}
static void *_p_BachelierYoYInflationCouponPricerTo_p_YoYInflationCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCouponPricer *)  ((BachelierYoYInflationCouponPricer *) x));
}
static void *_p_BlackYoYInflationCouponPricerTo_p_YoYInflationCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCouponPricer *)  ((BlackYoYInflationCouponPricer *) x));
}
static void *_p_UnitDisplacedBlackYoYInflationCouponPricerTo_p_YoYInflationCouponPricer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationCouponPricer *)  ((UnitDisplacedBlackYoYInflationCouponPricer *) x));
}
static void *_p_YYEUHICPTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYEUHICP *) x));
}
static void *_p_YYEUHICPXTTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYEUHICPXT *) x));
}
static void *_p_YYEUHICPrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYEUHICPr *) x));
}
static void *_p_YYFRHICPTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYFRHICP *) x));
}
static void *_p_YYFRHICPrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYFRHICPr *) x));
}
static void *_p_YYUKRPITo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYUKRPI *) x));
}
static void *_p_YYUKRPIrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYUKRPIr *) x));
}
static void *_p_YYUSCPITo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYUSCPI *) x));
}
static void *_p_YYUSCPIrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYUSCPIr *) x));
}
static void *_p_YYZACPITo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYZACPI *) x));
}
static void *_p_YYZACPIrTo_p_YoYInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationIndex *)  ((YYZACPIr *) x));
}
static void *_p_InterpolatedYoYInflationCurveT_Linear_tTo_p_YoYInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationTermStructure *)  ((InterpolatedYoYInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseYoYInflationCurveT_Linear_tTo_p_YoYInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYInflationTermStructure *)  ((PiecewiseYoYInflationCurve< Linear > *) x));
}
static void *_p_InterpolatedYoYOptionletStripperT_Linear_tTo_p_YoYOptionletStripper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletStripper *)  ((InterpolatedYoYOptionletStripper< Linear > *) x));
}
static void *_p_ConstantYoYOptionletVolatilityTo_p_YoYOptionletVolatilitySurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletVolatilitySurface *)  ((ConstantYoYOptionletVolatility *) x));
}
static void *_p_InterpolatedYoYOptionletVolatilityCurveT_Linear_tTo_p_YoYOptionletVolatilitySurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletVolatilitySurface *)  ((InterpolatedYoYOptionletVolatilityCurve< Linear > *) x));
}
static void *_p_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_tTo_p_YoYOptionletVolatilitySurface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((YoYOptionletVolatilitySurface *)  ((KInterpolatedYoYOptionletVolatilitySurface< Linear > *) x));
}
static void *_p_AUCPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((AUCPI *) x));
}
static void *_p_EUHICPTo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((EUHICP *) x));
}
static void *_p_EUHICPXTTo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((EUHICPXT *) x));
}
static void *_p_FRHICPTo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((FRHICP *) x));
}
static void *_p_UKHICPTo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((UKHICP *) x));
}
static void *_p_UKRPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((UKRPI *) x));
}
static void *_p_USCPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((USCPI *) x));
}
static void *_p_ZACPITo_p_ZeroInflationIndex(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationIndex *)  ((ZACPI *) x));
}
static void *_p_InterpolatedZeroInflationCurveT_Linear_tTo_p_ZeroInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationTermStructure *)  ((InterpolatedZeroInflationCurve< Linear > *) x));
}
static void *_p_PiecewiseZeroInflationCurveT_Linear_tTo_p_ZeroInflationTermStructure(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((ZeroInflationTermStructure *)  ((PiecewiseZeroInflationCurve< Linear > *) x));
}
static void *_p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_BarrierOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BarrierOption >(*(ext::shared_ptr< DividendBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierOption_tTo_p_ext__shared_ptrT_BarrierOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BarrierOption >(*(ext::shared_ptr< QuantoBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_AverageBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BasketPayoff >(*(ext::shared_ptr< AverageBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_MaxBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BasketPayoff >(*(ext::shared_ptr< MaxBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_MinBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BasketPayoff >(*(ext::shared_ptr< MinBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_SpreadBasketPayoff_tTo_p_ext__shared_ptrT_BasketPayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BasketPayoff >(*(ext::shared_ptr< SpreadBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_Bbsw_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bbsw >(*(ext::shared_ptr< Bbsw1M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_Bbsw_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bbsw >(*(ext::shared_ptr< Bbsw2M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_Bbsw_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bbsw >(*(ext::shared_ptr< Bbsw3M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_Bbsw_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bbsw >(*(ext::shared_ptr< Bbsw4M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_Bbsw_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bbsw >(*(ext::shared_ptr< Bbsw5M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_Bbsw_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bbsw >(*(ext::shared_ptr< Bbsw6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< Bibor1M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< Bibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< Bibor2M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< Bibor3M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< Bibor6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< Bibor9M > *)x);
}
static void *_p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_Bibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bibor >(*(ext::shared_ptr< BiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_Bkbm_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bkbm >(*(ext::shared_ptr< Bkbm1M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_Bkbm_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bkbm >(*(ext::shared_ptr< Bkbm2M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_Bkbm_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bkbm >(*(ext::shared_ptr< Bkbm3M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_Bkbm_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bkbm >(*(ext::shared_ptr< Bkbm4M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_Bkbm_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bkbm >(*(ext::shared_ptr< Bkbm5M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_Bkbm_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bkbm >(*(ext::shared_ptr< Bkbm6M > *)x);
}
static void *_p_ext__shared_ptrT_CapHelper_tTo_p_ext__shared_ptrT_BlackCalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackCalibrationHelper >(*(ext::shared_ptr< CapHelper > *)x);
}
static void *_p_ext__shared_ptrT_HestonModelHelper_tTo_p_ext__shared_ptrT_BlackCalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackCalibrationHelper >(*(ext::shared_ptr< HestonModelHelper > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionHelper_tTo_p_ext__shared_ptrT_BlackCalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackCalibrationHelper >(*(ext::shared_ptr< SwaptionHelper > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackVolTermStructure >(*(ext::shared_ptr< AndreasenHugeVolatilityAdapter > *)x);
}
static void *_p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackVolTermStructure >(*(ext::shared_ptr< BlackConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackVolTermStructure >(*(ext::shared_ptr< BlackVarianceCurve > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackVolTermStructure >(*(ext::shared_ptr< BlackVarianceSurface > *)x);
}
static void *_p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_BlackVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BlackVolTermStructure >(*(ext::shared_ptr< HestonBlackVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingCmsRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< AmortizingCmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< AmortizingFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< AmortizingFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< CPIBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< CallableBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< CallableFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< CallableZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< CmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< ConvertibleFixedCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< ConvertibleFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< ConvertibleZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< FixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< FloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_Bond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Bond >(*(ext::shared_ptr< ZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_BondForward_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BondForward >(*(ext::shared_ptr< FixedRateBondForward > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondHelper_tTo_p_ext__shared_ptrT_BondHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BondHelper >(*(ext::shared_ptr< FixedRateBondHelper > *)x);
}
static void *_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_tTo_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > >(*(ext::shared_ptr< YearOnYearInflationSwapHelper > *)x);
}
static void *_p_ext__shared_ptrT_YoYOptionletHelper_tTo_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > >(*(ext::shared_ptr< YoYOptionletHelper > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_tTo_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > >(*(ext::shared_ptr< ZeroCouponInflationSwapHelper > *)x);
}
static void *_p_ext__shared_ptrT_MTBrownianGenerator_tTo_p_ext__shared_ptrT_BrownianGenerator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BrownianGenerator >(*(ext::shared_ptr< MTBrownianGenerator > *)x);
}
static void *_p_ext__shared_ptrT_SobolBrownianGenerator_tTo_p_ext__shared_ptrT_BrownianGenerator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BrownianGenerator >(*(ext::shared_ptr< SobolBrownianGenerator > *)x);
}
static void *_p_ext__shared_ptrT_MTBrownianGeneratorFactory_tTo_p_ext__shared_ptrT_BrownianGeneratorFactory_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BrownianGeneratorFactory >(*(ext::shared_ptr< MTBrownianGeneratorFactory > *)x);
}
static void *_p_ext__shared_ptrT_SobolBrownianGeneratorFactory_tTo_p_ext__shared_ptrT_BrownianGeneratorFactory_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< BrownianGeneratorFactory >(*(ext::shared_ptr< SobolBrownianGeneratorFactory > *)x);
}
static void *_p_ext__shared_ptrT_BatesModel_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< BatesModel > *)x);
}
static void *_p_ext__shared_ptrT_BlackKarasinski_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< BlackKarasinski > *)x);
}
static void *_p_ext__shared_ptrT_CoxIngersollRoss_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< CoxIngersollRoss > *)x);
}
static void *_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< ExtendedCoxIngersollRoss > *)x);
}
static void *_p_ext__shared_ptrT_G2_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< G2 > *)x);
}
static void *_p_ext__shared_ptrT_GJRGARCHModel_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< GJRGARCHModel > *)x);
}
static void *_p_ext__shared_ptrT_GridModelLocalVolSurface_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< GridModelLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_HestonModel_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< HestonModel > *)x);
}
static void *_p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< HullWhite > *)x);
}
static void *_p_ext__shared_ptrT_OneFactorAffineModel_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< OneFactorAffineModel > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)x);
}
static void *_p_ext__shared_ptrT_ShortRateModel_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< ShortRateModel > *)x);
}
static void *_p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_CalibratedModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibratedModel >(*(ext::shared_ptr< Vasicek > *)x);
}
static void *_p_ext__shared_ptrT_BlackCalibrationHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibrationHelper >(*(ext::shared_ptr< BlackCalibrationHelper > *)x);
}
static void *_p_ext__shared_ptrT_CapHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibrationHelper >(*(ext::shared_ptr< CapHelper > *)x);
}
static void *_p_ext__shared_ptrT_HestonModelHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibrationHelper >(*(ext::shared_ptr< HestonModelHelper > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionHelper_tTo_p_ext__shared_ptrT_CalibrationHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CalibrationHelper >(*(ext::shared_ptr< SwaptionHelper > *)x);
}
static void *_p_ext__shared_ptrT_SoftCallability_tTo_p_ext__shared_ptrT_Callability_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Callability >(*(ext::shared_ptr< SoftCallability > *)x);
}
static void *_p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_CallableBond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CallableBond >(*(ext::shared_ptr< CallableFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_CallableBond_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CallableBond >(*(ext::shared_ptr< CallableZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_CapFloor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CapFloor >(*(ext::shared_ptr< Cap > *)x);
}
static void *_p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_CapFloor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CapFloor >(*(ext::shared_ptr< Collar > *)x);
}
static void *_p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_CapFloor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CapFloor >(*(ext::shared_ptr< Floor > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CapFloorTermVolatilityStructure >(*(ext::shared_ptr< CapFloorTermVolCurve > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CapFloorTermVolatilityStructure >(*(ext::shared_ptr< CapFloorTermVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_CappedFlooredCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CappedFlooredCoupon >(*(ext::shared_ptr< CappedFlooredCmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_CappedFlooredCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CappedFlooredCoupon >(*(ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_CappedFlooredCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CappedFlooredCoupon >(*(ext::shared_ptr< CappedFlooredIborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingPayment_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< AmortizingPayment > *)x);
}
static void *_p_ext__shared_ptrT_CPICashFlow_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CPICashFlow > *)x);
}
static void *_p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CPICoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CappedFlooredCmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CappedFlooredCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CappedFlooredIborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CappedFlooredYoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< CmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_Coupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< Coupon > *)x);
}
static void *_p_ext__shared_ptrT_Dividend_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< Dividend > *)x);
}
static void *_p_ext__shared_ptrT_EquityCashFlow_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< EquityCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_FixedDividend_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< FixedDividend > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< FixedRateCoupon > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< FloatingRateCoupon > *)x);
}
static void *_p_ext__shared_ptrT_FractionalDividend_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< FractionalDividend > *)x);
}
static void *_p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< IborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_IndexedCashFlow_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< IndexedCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_InflationCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< InflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< OvernightIndexedCoupon > *)x);
}
static void *_p_ext__shared_ptrT_Redemption_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< Redemption > *)x);
}
static void *_p_ext__shared_ptrT_SimpleCashFlow_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< SimpleCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_SubPeriodsCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< SubPeriodsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCoupon_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< YoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationCashFlow_tTo_p_ext__shared_ptrT_CashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CashFlow >(*(ext::shared_ptr< ZeroInflationCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_FaceValueAccrualClaim_tTo_p_ext__shared_ptrT_Claim_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Claim >(*(ext::shared_ptr< FaceValueAccrualClaim > *)x);
}
static void *_p_ext__shared_ptrT_FaceValueClaim_tTo_p_ext__shared_ptrT_Claim_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Claim >(*(ext::shared_ptr< FaceValueClaim > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHaganPricer_tTo_p_ext__shared_ptrT_CmsCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CmsCouponPricer >(*(ext::shared_ptr< AnalyticHaganPricer > *)x);
}
static void *_p_ext__shared_ptrT_LinearTsrPricer_tTo_p_ext__shared_ptrT_CmsCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CmsCouponPricer >(*(ext::shared_ptr< LinearTsrPricer > *)x);
}
static void *_p_ext__shared_ptrT_NumericHaganPricer_tTo_p_ext__shared_ptrT_CmsCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CmsCouponPricer >(*(ext::shared_ptr< NumericHaganPricer > *)x);
}
static void *_p_ext__shared_ptrT_LognormalCmsSpreadPricer_tTo_p_ext__shared_ptrT_CmsSpreadCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< CmsSpreadCouponPricer >(*(ext::shared_ptr< LognormalCmsSpreadPricer > *)x);
}
static void *_p_ext__shared_ptrT_BoundaryConstraint_tTo_p_ext__shared_ptrT_Constraint_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Constraint >(*(ext::shared_ptr< BoundaryConstraint > *)x);
}
static void *_p_ext__shared_ptrT_CompositeConstraint_tTo_p_ext__shared_ptrT_Constraint_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Constraint >(*(ext::shared_ptr< CompositeConstraint > *)x);
}
static void *_p_ext__shared_ptrT_NoConstraint_tTo_p_ext__shared_ptrT_Constraint_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Constraint >(*(ext::shared_ptr< NoConstraint > *)x);
}
static void *_p_ext__shared_ptrT_NonhomogeneousBoundaryConstraint_tTo_p_ext__shared_ptrT_Constraint_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Constraint >(*(ext::shared_ptr< NonhomogeneousBoundaryConstraint > *)x);
}
static void *_p_ext__shared_ptrT_PositiveConstraint_tTo_p_ext__shared_ptrT_Constraint_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Constraint >(*(ext::shared_ptr< PositiveConstraint > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_tTo_p_ext__shared_ptrT_ContinuousFixedLookbackOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ContinuousFixedLookbackOption >(*(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_tTo_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ContinuousFloatingLookbackOption >(*(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CPICoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CappedFlooredCmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CappedFlooredCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CappedFlooredIborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CappedFlooredYoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< CmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< FixedRateCoupon > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< FloatingRateCoupon > *)x);
}
static void *_p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< IborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_InflationCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< InflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< OvernightIndexedCoupon > *)x);
}
static void *_p_ext__shared_ptrT_SubPeriodsCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< SubPeriodsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCoupon_tTo_p_ext__shared_ptrT_Coupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Coupon >(*(ext::shared_ptr< YoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_DailyTenorLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DailyTenorLibor >(*(ext::shared_ptr< CADLiborON > *)x);
}
static void *_p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_DailyTenorLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DailyTenorLibor >(*(ext::shared_ptr< GBPLiborON > *)x);
}
static void *_p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_DailyTenorLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DailyTenorLibor >(*(ext::shared_ptr< USDLiborON > *)x);
}
static void *_p_ext__shared_ptrT_DirichletBC_tTo_p_ext__shared_ptrT_DefaultBoundaryCondition_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultBoundaryCondition >(*(ext::shared_ptr< DirichletBC > *)x);
}
static void *_p_ext__shared_ptrT_NeumannBC_tTo_p_ext__shared_ptrT_DefaultBoundaryCondition_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultBoundaryCondition >(*(ext::shared_ptr< NeumannBC > *)x);
}
static void *_p_ext__shared_ptrT_SpreadCdsHelper_tTo_p_ext__shared_ptrT_DefaultProbabilityHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityHelper >(*(ext::shared_ptr< SpreadCdsHelper > *)x);
}
static void *_p_ext__shared_ptrT_UpfrontCdsHelper_tTo_p_ext__shared_ptrT_DefaultProbabilityHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityHelper >(*(ext::shared_ptr< UpfrontCdsHelper > *)x);
}
static void *_p_ext__shared_ptrT_FlatHazardRate_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityTermStructure >(*(ext::shared_ptr< FlatHazardRate > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityTermStructure >(*(ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityTermStructure >(*(ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityTermStructure >(*(ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseFlatHazardRate_tTo_p_ext__shared_ptrT_DefaultProbabilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DefaultProbabilityTermStructure >(*(ext::shared_ptr< PiecewiseFlatHazardRate > *)x);
}
static void *_p_ext__shared_ptrT_FixedDividend_tTo_p_ext__shared_ptrT_Dividend_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Dividend >(*(ext::shared_ptr< FixedDividend > *)x);
}
static void *_p_ext__shared_ptrT_FractionalDividend_tTo_p_ext__shared_ptrT_Dividend_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Dividend >(*(ext::shared_ptr< FractionalDividend > *)x);
}
static void *_p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_DoubleBarrierOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< DoubleBarrierOption >(*(ext::shared_ptr< QuantoDoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor10M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor11M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor1M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor2M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor2W > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor3M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor4M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor5M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor6M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor7M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor8M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLibor9M > *)x);
}
static void *_p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_EURLibor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EURLibor >(*(ext::shared_ptr< EURLiborSW > *)x);
}
static void *_p_ext__shared_ptrT_EquityQuantoCashFlowPricer_tTo_p_ext__shared_ptrT_EquityCashFlowPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< EquityCashFlowPricer >(*(ext::shared_ptr< EquityQuantoCashFlowPricer > *)x);
}
static void *_p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< Euribor9M > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_Euribor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor >(*(ext::shared_ptr< EuriborSW > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_9M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_Euribor365_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Euribor365 >(*(ext::shared_ptr< Euribor365_SW > *)x);
}
static void *_p_ext__shared_ptrT_AmericanExercise_tTo_p_ext__shared_ptrT_Exercise_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Exercise >(*(ext::shared_ptr< AmericanExercise > *)x);
}
static void *_p_ext__shared_ptrT_BermudanExercise_tTo_p_ext__shared_ptrT_Exercise_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Exercise >(*(ext::shared_ptr< BermudanExercise > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanExercise_tTo_p_ext__shared_ptrT_Exercise_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Exercise >(*(ext::shared_ptr< EuropeanExercise > *)x);
}
static void *_p_ext__shared_ptrT_RebatedExercise_tTo_p_ext__shared_ptrT_Exercise_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Exercise >(*(ext::shared_ptr< RebatedExercise > *)x);
}
static void *_p_ext__shared_ptrT_SwingExercise_tTo_p_ext__shared_ptrT_Exercise_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Exercise >(*(ext::shared_ptr< SwingExercise > *)x);
}
static void *_p_ext__shared_ptrT_Concentrating1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< Concentrating1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_ExponentialJump1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< ExponentialJump1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_FdmBlackScholesMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< FdmBlackScholesMesher > *)x);
}
static void *_p_ext__shared_ptrT_FdmCEV1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< FdmCEV1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonLocalVolatilityVarianceMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< FdmHestonLocalVolatilityVarianceMesher > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonVarianceMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< FdmHestonVarianceMesher > *)x);
}
static void *_p_ext__shared_ptrT_FdmSimpleProcess1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< FdmSimpleProcess1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_Glued1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< Glued1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_Predefined1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< Predefined1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_Uniform1dMesher_tTo_p_ext__shared_ptrT_Fdm1dMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Fdm1dMesher >(*(ext::shared_ptr< Uniform1dMesher > *)x);
}
static void *_p_ext__shared_ptrT_FdmDirichletBoundary_tTo_p_ext__shared_ptrT_FdmBoundaryCondition_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmBoundaryCondition >(*(ext::shared_ptr< FdmDirichletBoundary > *)x);
}
static void *_p_ext__shared_ptrT_FdmDiscountDirichletBoundary_tTo_p_ext__shared_ptrT_FdmBoundaryCondition_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmBoundaryCondition >(*(ext::shared_ptr< FdmDiscountDirichletBoundary > *)x);
}
static void *_p_ext__shared_ptrT_FdmTimeDepDirichletBoundary_tTo_p_ext__shared_ptrT_FdmBoundaryCondition_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmBoundaryCondition >(*(ext::shared_ptr< FdmTimeDepDirichletBoundary > *)x);
}
static void *_p_ext__shared_ptrT_FdmLogInnerValue_tTo_p_ext__shared_ptrT_FdmCellAveragingInnerValue_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmCellAveragingInnerValue >(*(ext::shared_ptr< FdmLogInnerValue > *)x);
}
static void *_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_G2_t_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmAffineModelSwapInnerValue< G2 > > *)x);
}
static void *_p_ext__shared_ptrT_FdmAffineModelSwapInnerValueT_HullWhite_t_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmAffineModelSwapInnerValue< HullWhite > > *)x);
}
static void *_p_ext__shared_ptrT_FdmCellAveragingInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmCellAveragingInnerValue > *)x);
}
static void *_p_ext__shared_ptrT_FdmInnerValueCalculatorProxy_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmInnerValueCalculatorProxy > *)x);
}
static void *_p_ext__shared_ptrT_FdmLogBasketInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmLogBasketInnerValue > *)x);
}
static void *_p_ext__shared_ptrT_FdmLogInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmLogInnerValue > *)x);
}
static void *_p_ext__shared_ptrT_FdmZeroInnerValue_tTo_p_ext__shared_ptrT_FdmInnerValueCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmInnerValueCalculator >(*(ext::shared_ptr< FdmZeroInnerValue > *)x);
}
static void *_p_ext__shared_ptrT_Fdm2dBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< Fdm2dBlackScholesOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmBatesOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmBatesOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmBlackScholesFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmBlackScholesFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmBlackScholesOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmCEVOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmCEVOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmDupire1dOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmDupire1dOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmG2Op_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmG2Op > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmHestonFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmHestonHullWhiteOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmHestonOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmHullWhiteOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmLinearOpComposite_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmLinearOpComposite > *)x);
}
static void *_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmLinearOpCompositeProxy > *)x);
}
static void *_p_ext__shared_ptrT_FdmLocalVolFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmLocalVolFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmOrnsteinUhlenbeckOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmSabrOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmSabrOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmSquareRootFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmSquareRootFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmZabrOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FdmZabrOp > *)x);
}
static void *_p_ext__shared_ptrT_FirstDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< FirstDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_NinePointLinearOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< NinePointLinearOp > *)x);
}
static void *_p_ext__shared_ptrT_NthOrderDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< NthOrderDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_SecondDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< SecondDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< SecondOrderMixedDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_TripleBandLinearOp_tTo_p_ext__shared_ptrT_FdmLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOp >(*(ext::shared_ptr< TripleBandLinearOp > *)x);
}
static void *_p_ext__shared_ptrT_Fdm2dBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< Fdm2dBlackScholesOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmBatesOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmBatesOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmBlackScholesFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmBlackScholesFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmBlackScholesOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmBlackScholesOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmCEVOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmCEVOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmDupire1dOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmDupire1dOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmG2Op_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmG2Op > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmHestonFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmHestonHullWhiteOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmHestonOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmHestonOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmHullWhiteOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmHullWhiteOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmLinearOpCompositeProxy_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmLinearOpCompositeProxy > *)x);
}
static void *_p_ext__shared_ptrT_FdmLocalVolFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmLocalVolFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmOrnsteinUhlenbeckOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmOrnsteinUhlenbeckOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmSabrOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmSabrOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmSquareRootFwdOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmSquareRootFwdOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmZabrOp_tTo_p_ext__shared_ptrT_FdmLinearOpComposite_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmLinearOpComposite >(*(ext::shared_ptr< FdmZabrOp > *)x);
}
static void *_p_ext__shared_ptrT_FdmMesherComposite_tTo_p_ext__shared_ptrT_FdmMesher_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FdmMesher >(*(ext::shared_ptr< FdmMesherComposite > *)x);
}
static void *_p_ext__shared_ptrT_CubicBSplinesFitting_tTo_p_ext__shared_ptrT_FittingMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FittingMethod >(*(ext::shared_ptr< CubicBSplinesFitting > *)x);
}
static void *_p_ext__shared_ptrT_ExponentialSplinesFitting_tTo_p_ext__shared_ptrT_FittingMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FittingMethod >(*(ext::shared_ptr< ExponentialSplinesFitting > *)x);
}
static void *_p_ext__shared_ptrT_NelsonSiegelFitting_tTo_p_ext__shared_ptrT_FittingMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FittingMethod >(*(ext::shared_ptr< NelsonSiegelFitting > *)x);
}
static void *_p_ext__shared_ptrT_SimplePolynomialFitting_tTo_p_ext__shared_ptrT_FittingMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FittingMethod >(*(ext::shared_ptr< SimplePolynomialFitting > *)x);
}
static void *_p_ext__shared_ptrT_SpreadFittingMethod_tTo_p_ext__shared_ptrT_FittingMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FittingMethod >(*(ext::shared_ptr< SpreadFittingMethod > *)x);
}
static void *_p_ext__shared_ptrT_SvenssonFitting_tTo_p_ext__shared_ptrT_FittingMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FittingMethod >(*(ext::shared_ptr< SvenssonFitting > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< CappedFlooredCmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< CappedFlooredCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< CappedFlooredIborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< CmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< CmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< IborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< OvernightIndexedCoupon > *)x);
}
static void *_p_ext__shared_ptrT_SubPeriodsCoupon_tTo_p_ext__shared_ptrT_FloatingRateCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCoupon >(*(ext::shared_ptr< SubPeriodsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHaganPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< AnalyticHaganPricer > *)x);
}
static void *_p_ext__shared_ptrT_AveragingRatePricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< AveragingRatePricer > *)x);
}
static void *_p_ext__shared_ptrT_BlackIborCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< BlackIborCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_CmsCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< CmsCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_CmsSpreadCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< CmsSpreadCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_CompoundingRatePricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< CompoundingRatePricer > *)x);
}
static void *_p_ext__shared_ptrT_IborCouponPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< IborCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_LinearTsrPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< LinearTsrPricer > *)x);
}
static void *_p_ext__shared_ptrT_LognormalCmsSpreadPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< LognormalCmsSpreadPricer > *)x);
}
static void *_p_ext__shared_ptrT_NumericHaganPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< NumericHaganPricer > *)x);
}
static void *_p_ext__shared_ptrT_SubPeriodsPricer_tTo_p_ext__shared_ptrT_FloatingRateCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< FloatingRateCouponPricer >(*(ext::shared_ptr< SubPeriodsPricer > *)x);
}
static void *_p_ext__shared_ptrT_BondForward_tTo_p_ext__shared_ptrT_Forward_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Forward >(*(ext::shared_ptr< BondForward > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_Forward_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Forward >(*(ext::shared_ptr< FixedRateBondForward > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_ForwardVanillaOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ForwardVanillaOption >(*(ext::shared_ptr< QuantoForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_Gsr_tTo_p_ext__shared_ptrT_Gaussian1dModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Gaussian1dModel >(*(ext::shared_ptr< Gsr > *)x);
}
static void *_p_ext__shared_ptrT_MarkovFunctional_tTo_p_ext__shared_ptrT_Gaussian1dModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Gaussian1dModel >(*(ext::shared_ptr< MarkovFunctional > *)x);
}
static void *_p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< GeneralizedBlackScholesProcess >(*(ext::shared_ptr< BlackProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< GeneralizedBlackScholesProcess >(*(ext::shared_ptr< BlackScholesMertonProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< GeneralizedBlackScholesProcess >(*(ext::shared_ptr< BlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< GeneralizedBlackScholesProcess >(*(ext::shared_ptr< GarmanKohlagenProcess > *)x);
}
static void *_p_ext__shared_ptrT_BatesModel_tTo_p_ext__shared_ptrT_HestonModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< HestonModel >(*(ext::shared_ptr< BatesModel > *)x);
}
static void *_p_ext__shared_ptrT_BatesProcess_tTo_p_ext__shared_ptrT_HestonProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< HestonProcess >(*(ext::shared_ptr< BatesProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackIborCouponPricer_tTo_p_ext__shared_ptrT_IborCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborCouponPricer >(*(ext::shared_ptr< BlackIborCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< AUDLibor > *)x);
}
static void *_p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Aonia > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw1M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw2M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw3M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw4M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw5M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bbsw6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor1M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor2M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor3M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bibor9M > *)x);
}
static void *_p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< BiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm1M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm2M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm3M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm4M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm5M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Bkbm6M > *)x);
}
static void *_p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< CADLibor > *)x);
}
static void *_p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< CADLiborON > *)x);
}
static void *_p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< CHFLibor > *)x);
}
static void *_p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Cdor > *)x);
}
static void *_p_ext__shared_ptrT_Corra_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Corra > *)x);
}
static void *_p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< DKKLibor > *)x);
}
static void *_p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< DailyTenorLibor > *)x);
}
static void *_p_ext__shared_ptrT_Destr_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Destr > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor10M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor11M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor1M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor2M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor2W > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor3M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor4M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor5M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor6M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor7M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor8M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLibor9M > *)x);
}
static void *_p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EURLiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Eonia > *)x);
}
static void *_p_ext__shared_ptrT_Estr_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Estr > *)x);
}
static void *_p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor > *)x);
}
static void *_p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365 > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_9M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor365_SW > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Euribor9M > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< EuriborSW > *)x);
}
static void *_p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< FedFunds > *)x);
}
static void *_p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< GBPLibor > *)x);
}
static void *_p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< GBPLiborON > *)x);
}
static void *_p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< JPYLibor > *)x);
}
static void *_p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Jibar > *)x);
}
static void *_p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Libor > *)x);
}
static void *_p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Mosprime > *)x);
}
static void *_p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< NZDLibor > *)x);
}
static void *_p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Nzocr > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< OvernightIndex > *)x);
}
static void *_p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Pribor > *)x);
}
static void *_p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Robor > *)x);
}
static void *_p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< SEKLibor > *)x);
}
static void *_p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Shibor > *)x);
}
static void *_p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Sofr > *)x);
}
static void *_p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Sonia > *)x);
}
static void *_p_ext__shared_ptrT_Swestr_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Swestr > *)x);
}
static void *_p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< THBFIX > *)x);
}
static void *_p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< TRLibor > *)x);
}
static void *_p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Tibor > *)x);
}
static void *_p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< USDLibor > *)x);
}
static void *_p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< USDLiborON > *)x);
}
static void *_p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Wibor > *)x);
}
static void *_p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_IborIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IborIndex >(*(ext::shared_ptr< Zibor > *)x);
}
static void *_p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< AUCPI > *)x);
}
static void *_p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< AUDLibor > *)x);
}
static void *_p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Aonia > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw1M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw2M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw3M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw4M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw5M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bbsw6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor1M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor2M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor3M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bibor9M > *)x);
}
static void *_p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< BiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm1M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm2M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm3M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm4M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm5M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Bkbm6M > *)x);
}
static void *_p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< CADLibor > *)x);
}
static void *_p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< CADLiborON > *)x);
}
static void *_p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< CHFLibor > *)x);
}
static void *_p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Cdor > *)x);
}
static void *_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< ChfLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_Corra_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Corra > *)x);
}
static void *_p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< DKKLibor > *)x);
}
static void *_p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< DailyTenorLibor > *)x);
}
static void *_p_ext__shared_ptrT_Destr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Destr > *)x);
}
static void *_p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EUHICP > *)x);
}
static void *_p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor10M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor11M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor1M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor2M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor2W > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor3M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor4M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor5M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor6M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor7M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor8M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLibor9M > *)x);
}
static void *_p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EURLiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Eonia > *)x);
}
static void *_p_ext__shared_ptrT_EquityIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EquityIndex > *)x);
}
static void *_p_ext__shared_ptrT_Estr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Estr > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EurLiborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EurLiborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EurLiborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor > *)x);
}
static void *_p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365 > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_9M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor365_SW > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Euribor9M > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EuriborSW > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EuriborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EuriborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< EuriborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< FRHICP > *)x);
}
static void *_p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< FedFunds > *)x);
}
static void *_p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< GBPLibor > *)x);
}
static void *_p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< GBPLiborON > *)x);
}
static void *_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< GbpLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_IborIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< IborIndex > *)x);
}
static void *_p_ext__shared_ptrT_InflationIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< InflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_InterestRateIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< InterestRateIndex > *)x);
}
static void *_p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< JPYLibor > *)x);
}
static void *_p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Jibar > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< JpyLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< JpyLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Libor > *)x);
}
static void *_p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Mosprime > *)x);
}
static void *_p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< NZDLibor > *)x);
}
static void *_p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Nzocr > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< OvernightIndex > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< OvernightIndexedSwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Pribor > *)x);
}
static void *_p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Robor > *)x);
}
static void *_p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< SEKLibor > *)x);
}
static void *_p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Shibor > *)x);
}
static void *_p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Sofr > *)x);
}
static void *_p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Sonia > *)x);
}
static void *_p_ext__shared_ptrT_SwapIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< SwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_SwapSpreadIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< SwapSpreadIndex > *)x);
}
static void *_p_ext__shared_ptrT_Swestr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Swestr > *)x);
}
static void *_p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< THBFIX > *)x);
}
static void *_p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< TRLibor > *)x);
}
static void *_p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Tibor > *)x);
}
static void *_p_ext__shared_ptrT_UKHICP_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< UKHICP > *)x);
}
static void *_p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< UKRPI > *)x);
}
static void *_p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< USCPI > *)x);
}
static void *_p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< USDLibor > *)x);
}
static void *_p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< USDLiborON > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< UsdLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< UsdLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Wibor > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYEUHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYEUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYEUHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYFRHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYFRHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYUKRPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYUKRPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYUSCPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYUSCPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYZACPI > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YYZACPIr > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< YoYInflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< ZACPI > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationIndex_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< ZeroInflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_Index_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Index >(*(ext::shared_ptr< Zibor > *)x);
}
static void *_p_ext__shared_ptrT_CPICashFlow_tTo_p_ext__shared_ptrT_IndexedCashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IndexedCashFlow >(*(ext::shared_ptr< CPICashFlow > *)x);
}
static void *_p_ext__shared_ptrT_EquityCashFlow_tTo_p_ext__shared_ptrT_IndexedCashFlow_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< IndexedCashFlow >(*(ext::shared_ptr< EquityCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_InflationCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationCoupon >(*(ext::shared_ptr< CPICoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_tTo_p_ext__shared_ptrT_InflationCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationCoupon >(*(ext::shared_ptr< CappedFlooredYoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCoupon_tTo_p_ext__shared_ptrT_InflationCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationCoupon >(*(ext::shared_ptr< YoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< AUCPI > *)x);
}
static void *_p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< EUHICP > *)x);
}
static void *_p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< EUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< FRHICP > *)x);
}
static void *_p_ext__shared_ptrT_UKHICP_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< UKHICP > *)x);
}
static void *_p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< UKRPI > *)x);
}
static void *_p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< USCPI > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYEUHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYEUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYEUHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYFRHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYFRHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYUKRPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYUKRPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYUSCPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYUSCPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYZACPI > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YYZACPIr > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationIndex_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< YoYInflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< ZACPI > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationIndex_tTo_p_ext__shared_ptrT_InflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationIndex >(*(ext::shared_ptr< ZeroInflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< YoYCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationTermStructure_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< YoYInflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationTermStructure_tTo_p_ext__shared_ptrT_InflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InflationTermStructure >(*(ext::shared_ptr< ZeroInflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingCmsRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< AmortizingCmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< AmortizingFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< AmortizingFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ArithmeticAverageOIS_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ArithmeticAverageOIS > *)x);
}
static void *_p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< AssetSwap > *)x);
}
static void *_p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< BarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< BasketOption > *)x);
}
static void *_p_ext__shared_ptrT_Bond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Bond > *)x);
}
static void *_p_ext__shared_ptrT_BondForward_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< BondForward > *)x);
}
static void *_p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CPIBond > *)x);
}
static void *_p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CPISwap > *)x);
}
static void *_p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CallableBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CallableFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CallableZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Cap > *)x);
}
static void *_p_ext__shared_ptrT_CapFloor_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CapFloor > *)x);
}
static void *_p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CdsOption > *)x);
}
static void *_p_ext__shared_ptrT_CliquetOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CliquetOption > *)x);
}
static void *_p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Collar > *)x);
}
static void *_p_ext__shared_ptrT_ComplexChooserOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ComplexChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_CompositeInstrument_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CompositeInstrument > *)x);
}
static void *_p_ext__shared_ptrT_CompoundOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CompoundOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ContinuousAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFixedLookbackOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ContinuousFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ContinuousFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ConvertibleFixedCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ConvertibleFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ConvertibleZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_CreditDefaultSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< CreditDefaultSwap > *)x);
}
static void *_p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< DiscreteAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< DividendBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< DividendVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< DoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_EquityTotalReturnSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< EquityTotalReturnSwap > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< EuropeanOption > *)x);
}
static void *_p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< EverestOption > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< FixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< FixedRateBondForward > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< FloatFloatSwap > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwaption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< FloatFloatSwaption > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< FloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Floor > *)x);
}
static void *_p_ext__shared_ptrT_Forward_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Forward > *)x);
}
static void *_p_ext__shared_ptrT_ForwardRateAgreement_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ForwardRateAgreement > *)x);
}
static void *_p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< HimalayaOption > *)x);
}
static void *_p_ext__shared_ptrT_MargrabeOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< MargrabeOption > *)x);
}
static void *_p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< MultiAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< NonstandardSwap > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwaption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< NonstandardSwaption > *)x);
}
static void *_p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< OneAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_Option_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Option > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexFuture_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< OvernightIndexFuture > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< OvernightIndexedSwap > *)x);
}
static void *_p_ext__shared_ptrT_PartialTimeBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< PartialTimeBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< QuantoBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< QuantoDoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< QuantoForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< QuantoVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_SimpleChooserOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< SimpleChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< SpreadOption > *)x);
}
static void *_p_ext__shared_ptrT_Stock_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Stock > *)x);
}
static void *_p_ext__shared_ptrT_Swap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Swap > *)x);
}
static void *_p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< Swaption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< VanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< VanillaSwap > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< VanillaSwingOption > *)x);
}
static void *_p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< YearOnYearInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< YoYInflationCap > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloor_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< YoYInflationCapFloor > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< YoYInflationCollar > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< YoYInflationFloor > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ZeroCouponInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponSwap_tTo_p_ext__shared_ptrT_Instrument_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Instrument >(*(ext::shared_ptr< ZeroCouponSwap > *)x);
}
static void *_p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< AUDLibor > *)x);
}
static void *_p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Aonia > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw1M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw2M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw3M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw4M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw5M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bbsw6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor1M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor2M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor3M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bibor9M > *)x);
}
static void *_p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< BiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm1M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm2M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm3M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm4M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm5M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Bkbm6M > *)x);
}
static void *_p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< CADLibor > *)x);
}
static void *_p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< CADLiborON > *)x);
}
static void *_p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< CHFLibor > *)x);
}
static void *_p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Cdor > *)x);
}
static void *_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< ChfLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_Corra_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Corra > *)x);
}
static void *_p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< DKKLibor > *)x);
}
static void *_p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< DailyTenorLibor > *)x);
}
static void *_p_ext__shared_ptrT_Destr_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Destr > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor10M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor11M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor1M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor2M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor2W > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor3M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor4M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor5M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor6M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor7M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor8M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLibor9M > *)x);
}
static void *_p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EURLiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Eonia > *)x);
}
static void *_p_ext__shared_ptrT_Estr_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Estr > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EurLiborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EurLiborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EurLiborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor > *)x);
}
static void *_p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365 > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_9M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor365_SW > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Euribor9M > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EuriborSW > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EuriborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EuriborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< EuriborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< FedFunds > *)x);
}
static void *_p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< GBPLibor > *)x);
}
static void *_p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< GBPLiborON > *)x);
}
static void *_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< GbpLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_IborIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< IborIndex > *)x);
}
static void *_p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< JPYLibor > *)x);
}
static void *_p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Jibar > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< JpyLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< JpyLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Libor > *)x);
}
static void *_p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Mosprime > *)x);
}
static void *_p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< NZDLibor > *)x);
}
static void *_p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Nzocr > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< OvernightIndex > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< OvernightIndexedSwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Pribor > *)x);
}
static void *_p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Robor > *)x);
}
static void *_p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< SEKLibor > *)x);
}
static void *_p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Shibor > *)x);
}
static void *_p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Sofr > *)x);
}
static void *_p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Sonia > *)x);
}
static void *_p_ext__shared_ptrT_SwapIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< SwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_SwapSpreadIndex_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< SwapSpreadIndex > *)x);
}
static void *_p_ext__shared_ptrT_Swestr_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Swestr > *)x);
}
static void *_p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< THBFIX > *)x);
}
static void *_p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< TRLibor > *)x);
}
static void *_p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Tibor > *)x);
}
static void *_p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< USDLibor > *)x);
}
static void *_p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< USDLiborON > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< UsdLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< UsdLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Wibor > *)x);
}
static void *_p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_InterestRateIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< InterestRateIndex >(*(ext::shared_ptr< Zibor > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingCmsRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< AmortizingCmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< AmortizingFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< AmortizingFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ArithmeticAverageOIS_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ArithmeticAverageOIS > *)x);
}
static void *_p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< AssetSwap > *)x);
}
static void *_p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< BarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< BasketOption > *)x);
}
static void *_p_ext__shared_ptrT_Bond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Bond > *)x);
}
static void *_p_ext__shared_ptrT_BondForward_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< BondForward > *)x);
}
static void *_p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CPIBond > *)x);
}
static void *_p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CPISwap > *)x);
}
static void *_p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CallableBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CallableFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CallableZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Cap > *)x);
}
static void *_p_ext__shared_ptrT_CapFloor_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CapFloor > *)x);
}
static void *_p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CdsOption > *)x);
}
static void *_p_ext__shared_ptrT_CliquetOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CliquetOption > *)x);
}
static void *_p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Collar > *)x);
}
static void *_p_ext__shared_ptrT_ComplexChooserOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ComplexChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_CompositeInstrument_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CompositeInstrument > *)x);
}
static void *_p_ext__shared_ptrT_CompoundOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CompoundOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ContinuousAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFixedLookbackOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ContinuousFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ContinuousFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ConvertibleFixedCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ConvertibleFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ConvertibleZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_CreditDefaultSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< CreditDefaultSwap > *)x);
}
static void *_p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< DiscreteAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< DividendBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< DividendVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< DoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_EquityTotalReturnSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< EquityTotalReturnSwap > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< EuropeanOption > *)x);
}
static void *_p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< EverestOption > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< FixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< FixedRateBondForward > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< FloatFloatSwap > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwaption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< FloatFloatSwaption > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< FloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Floor > *)x);
}
static void *_p_ext__shared_ptrT_Forward_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Forward > *)x);
}
static void *_p_ext__shared_ptrT_ForwardRateAgreement_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ForwardRateAgreement > *)x);
}
static void *_p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< HimalayaOption > *)x);
}
static void *_p_ext__shared_ptrT_Instrument_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Instrument > *)x);
}
static void *_p_ext__shared_ptrT_MargrabeOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< MargrabeOption > *)x);
}
static void *_p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< MultiAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< NonstandardSwap > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwaption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< NonstandardSwaption > *)x);
}
static void *_p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< OneAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_Option_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Option > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexFuture_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< OvernightIndexFuture > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< OvernightIndexedSwap > *)x);
}
static void *_p_ext__shared_ptrT_PartialTimeBarrierOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< PartialTimeBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< QuantoBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< QuantoDoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< QuantoForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< QuantoVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_SimpleChooserOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< SimpleChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< SpreadOption > *)x);
}
static void *_p_ext__shared_ptrT_Stock_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Stock > *)x);
}
static void *_p_ext__shared_ptrT_Swap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Swap > *)x);
}
static void *_p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< Swaption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< VanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< VanillaSwap > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< VanillaSwingOption > *)x);
}
static void *_p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< YearOnYearInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< YoYInflationCap > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloor_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< YoYInflationCapFloor > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< YoYInflationCollar > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< YoYInflationFloor > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ZeroCouponInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponSwap_tTo_p_ext__shared_ptrT_LazyObject_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LazyObject >(*(ext::shared_ptr< ZeroCouponSwap > *)x);
}
static void *_p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolSurface_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolSurface >(*(ext::shared_ptr< NoExceptLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolTermStructure >(*(ext::shared_ptr< AndreasenHugeLocalVolAdapter > *)x);
}
static void *_p_ext__shared_ptrT_FixedLocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolTermStructure >(*(ext::shared_ptr< FixedLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_GridModelLocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolTermStructure >(*(ext::shared_ptr< GridModelLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolTermStructure >(*(ext::shared_ptr< LocalConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolTermStructure >(*(ext::shared_ptr< LocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_LocalVolTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< LocalVolTermStructure >(*(ext::shared_ptr< NoExceptLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_AbcdVol_tTo_p_ext__shared_ptrT_MarketModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MarketModel >(*(ext::shared_ptr< AbcdVol > *)x);
}
static void *_p_ext__shared_ptrT_LogNormalFwdRateIpc_tTo_p_ext__shared_ptrT_MarketModelEvolver_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MarketModelEvolver >(*(ext::shared_ptr< LogNormalFwdRateIpc > *)x);
}
static void *_p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MultiAssetOption >(*(ext::shared_ptr< BasketOption > *)x);
}
static void *_p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MultiAssetOption >(*(ext::shared_ptr< EverestOption > *)x);
}
static void *_p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MultiAssetOption >(*(ext::shared_ptr< HimalayaOption > *)x);
}
static void *_p_ext__shared_ptrT_MargrabeOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MultiAssetOption >(*(ext::shared_ptr< MargrabeOption > *)x);
}
static void *_p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_MultiAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< MultiAssetOption >(*(ext::shared_ptr< SpreadOption > *)x);
}
static void *_p_ext__shared_ptrT_SecondOrderMixedDerivativeOp_tTo_p_ext__shared_ptrT_NinePointLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< NinePointLinearOp >(*(ext::shared_ptr< SecondOrderMixedDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AUCPI > *)x);
}
static void *_p_ext__shared_ptrT_AUDLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AUDLibor > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingCmsRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AmortizingCmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFixedRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AmortizingFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingFloatingRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AmortizingFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_AmortizingPayment_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AmortizingPayment > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticAmericanMargrabeEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticAmericanMargrabeEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticBSMHullWhiteEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticBinaryBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCEVEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticCEVEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCliquetEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticCliquetEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticComplexChooserEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticComplexChooserEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCompoundOptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticCompoundOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousFixedLookbackEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticContinuousFixedLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousFloatingLookbackEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticContinuousFloatingLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousPartialFixedLookbackEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticContinuousPartialFixedLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousPartialFloatingLookbackEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticContinuousPartialFloatingLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDigitalAmericanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDigitalAmericanKOEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDividendEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticDoubleBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticEuropeanMargrabeEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticEuropeanMargrabeEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticGJRGARCHEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticH1HWEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticH1HWEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHestonEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticHestonForwardEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticHestonHullWhiteEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticPTDHestonEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticPTDHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticPartialTimeBarrierOptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticPartialTimeBarrierOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticPerformanceEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticPerformanceEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticSimpleChooserEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AnalyticSimpleChooserEngine > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AndreasenHugeLocalVolAdapter > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AndreasenHugeVolatilityAdapter > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeVolatilityInterpl_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AndreasenHugeVolatilityInterpl > *)x);
}
static void *_p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Aonia > *)x);
}
static void *_p_ext__shared_ptrT_ArithmeticAverageOIS_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ArithmeticAverageOIS > *)x);
}
static void *_p_ext__shared_ptrT_ArithmeticOISRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ArithmeticOISRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< AssetSwap > *)x);
}
static void *_p_ext__shared_ptrT_BachelierCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BachelierCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_BachelierSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BachelierSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > *)x);
}
static void *_p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BasketOption > *)x);
}
static void *_p_ext__shared_ptrT_BatesEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BatesEngine > *)x);
}
static void *_p_ext__shared_ptrT_BatesModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BatesModel > *)x);
}
static void *_p_ext__shared_ptrT_BatesProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BatesProcess > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw1M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw1M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw2M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw2M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw3M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw3M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw4M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw4M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw5M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw5M > *)x);
}
static void *_p_ext__shared_ptrT_Bbsw6M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bbsw6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor1M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor1Y_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Bibor2M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor2M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor3M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor3M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor6M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor6M > *)x);
}
static void *_p_ext__shared_ptrT_Bibor9M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bibor9M > *)x);
}
static void *_p_ext__shared_ptrT_BiborSW_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BiborSW > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< Tian > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< Tian > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > *)x);
}
static void *_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BjerksundStenslandApproximationEngine > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm1M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm1M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm2M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm2M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm3M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm3M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm4M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm4M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm5M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm5M > *)x);
}
static void *_p_ext__shared_ptrT_Bkbm6M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bkbm6M > *)x);
}
static void *_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackCallableFixedRateBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackCdsOptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackCdsOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_BlackKarasinski_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackKarasinski > *)x);
}
static void *_p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackScholesMertonProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackVarianceCurve > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackVarianceSurface > *)x);
}
static void *_p_ext__shared_ptrT_BlackVolTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BlackVolTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Bond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Bond > *)x);
}
static void *_p_ext__shared_ptrT_BondForward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BondForward > *)x);
}
static void *_p_ext__shared_ptrT_BondHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BondHelper > *)x);
}
static void *_p_ext__shared_ptrT_BootstrapHelperT_YoYInflationTermStructure_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BootstrapHelper< YoYInflationTermStructure > > *)x);
}
static void *_p_ext__shared_ptrT_BootstrapHelperT_YoYOptionletVolatilitySurface_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BootstrapHelper< YoYOptionletVolatilitySurface > > *)x);
}
static void *_p_ext__shared_ptrT_BootstrapHelperT_ZeroInflationTermStructure_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< BootstrapHelper< ZeroInflationTermStructure > > *)x);
}
static void *_p_ext__shared_ptrT_CADLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CADLibor > *)x);
}
static void *_p_ext__shared_ptrT_CADLiborON_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CADLiborON > *)x);
}
static void *_p_ext__shared_ptrT_CHFLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CHFLibor > *)x);
}
static void *_p_ext__shared_ptrT_COSHestonEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< COSHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_CPIBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CPIBond > *)x);
}
static void *_p_ext__shared_ptrT_CPICashFlow_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CPICashFlow > *)x);
}
static void *_p_ext__shared_ptrT_CPICoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CPICoupon > *)x);
}
static void *_p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CPISwap > *)x);
}
static void *_p_ext__shared_ptrT_CalibratedModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CalibratedModel > *)x);
}
static void *_p_ext__shared_ptrT_CallableBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CallableBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableFixedRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CallableFixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CallableZeroCouponBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CallableZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_Cap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Cap > *)x);
}
static void *_p_ext__shared_ptrT_CapFloor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CapFloor > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CapFloorTermVolCurve > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CapFloorTermVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CapFloorTermVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CappedFlooredCmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCmsSpreadCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CappedFlooredCmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CappedFlooredCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredIborCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CappedFlooredIborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CappedFlooredYoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CashFlow_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CashFlow > *)x);
}
static void *_p_ext__shared_ptrT_Cdor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Cdor > *)x);
}
static void *_p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CdsOption > *)x);
}
static void *_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ChfLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_CliquetOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CliquetOption > *)x);
}
static void *_p_ext__shared_ptrT_CmsCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CmsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_CmsRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CmsRateBond > *)x);
}
static void *_p_ext__shared_ptrT_CmsSpreadCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CmsSpreadCoupon > *)x);
}
static void *_p_ext__shared_ptrT_Collar_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Collar > *)x);
}
static void *_p_ext__shared_ptrT_ComplexChooserOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ComplexChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_CompositeInstrument_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CompositeInstrument > *)x);
}
static void *_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CompositeQuote< BinaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CompositeZeroYieldStructure< BinaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_CompoundOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CompoundOption > *)x);
}
static void *_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConstantOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConstantSwaptionVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConstantYoYOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ContinuousAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFixedLookbackOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ContinuousFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ContinuousFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFixedCouponBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConvertibleFixedCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleFloatingRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConvertibleFloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_ConvertibleZeroCouponBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ConvertibleZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_Corra_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Corra > *)x);
}
static void *_p_ext__shared_ptrT_Coupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Coupon > *)x);
}
static void *_p_ext__shared_ptrT_CoxIngersollRoss_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CoxIngersollRoss > *)x);
}
static void *_p_ext__shared_ptrT_CreditDefaultSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< CreditDefaultSwap > *)x);
}
static void *_p_ext__shared_ptrT_DKKLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DKKLibor > *)x);
}
static void *_p_ext__shared_ptrT_DailyTenorLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DailyTenorLibor > *)x);
}
static void *_p_ext__shared_ptrT_DatedOISRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DatedOISRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_DefaultProbabilityHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DefaultProbabilityHelper > *)x);
}
static void *_p_ext__shared_ptrT_DefaultProbabilityTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DefaultProbabilityTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_DeltaVolQuote_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DeltaVolQuote > *)x);
}
static void *_p_ext__shared_ptrT_DepositRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DepositRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DerivedQuote< UnaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_Destr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Destr > *)x);
}
static void *_p_ext__shared_ptrT_DiscountingBondEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DiscountingBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_DiscountingSwapEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DiscountingSwapEngine > *)x);
}
static void *_p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DiscreteAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_Dividend_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Dividend > *)x);
}
static void *_p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DividendBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DividendVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< DoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EUHICP > *)x);
}
static void *_p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor10M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor10M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor11M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor11M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor1M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor1Y_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor1Y > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor2M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor2W_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor2W > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor3M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor3M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor4M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor4M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor5M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor5M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor6M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor6M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor7M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor7M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor8M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor8M > *)x);
}
static void *_p_ext__shared_ptrT_EURLibor9M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLibor9M > *)x);
}
static void *_p_ext__shared_ptrT_EURLiborSW_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EURLiborSW > *)x);
}
static void *_p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Eonia > *)x);
}
static void *_p_ext__shared_ptrT_EquityCashFlow_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EquityCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_EquityIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EquityIndex > *)x);
}
static void *_p_ext__shared_ptrT_EquityTotalReturnSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EquityTotalReturnSwap > *)x);
}
static void *_p_ext__shared_ptrT_Estr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Estr > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EurLiborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EurLiborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EurLiborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_Euribor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor > *)x);
}
static void *_p_ext__shared_ptrT_Euribor10M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor11M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor1Y_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor2W_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365 > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_10M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_10M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_11M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_11M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_1M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_1Y_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_1Y > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_2M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_2W_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_2W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_3W_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_4M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_5M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_6M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_7M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_8M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_9M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_9M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor365_SW_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor365_SW > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor3M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor3W_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor3W > *)x);
}
static void *_p_ext__shared_ptrT_Euribor4M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor4M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor5M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor5M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor6M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor6M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor7M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor7M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor8M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor8M > *)x);
}
static void *_p_ext__shared_ptrT_Euribor9M_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Euribor9M > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSW_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EuriborSW > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EuriborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EuriborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EuriborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EuropeanOption > *)x);
}
static void *_p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< EverestOption > *)x);
}
static void *_p_ext__shared_ptrT_ExponentialFittingHestonEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ExponentialFittingHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_ExtOUWithJumpsProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ExtOUWithJumpsProcess > *)x);
}
static void *_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ExtendedCoxIngersollRoss > *)x);
}
static void *_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *)x);
}
static void *_p_ext__shared_ptrT_FFTVarianceGammaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FFTVarianceGammaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FRHICP > *)x);
}
static void *_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Fd2dBlackScholesVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBatesVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdBatesVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesAsianEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdBlackScholesAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdBlackScholesBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesRebateEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdBlackScholesRebateEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesShoutEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdBlackScholesShoutEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdBlackScholesVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdCEVVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdCEVVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdG2SwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdG2SwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdHestonBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdHestonDoubleBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdHestonHullWhiteVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonRebateEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdHestonRebateEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdHestonVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdHullWhiteSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdSabrVanillaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdSabrVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdSimpleBSSwingEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdSimpleBSSwingEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > *)x);
}
static void *_p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FedFunds > *)x);
}
static void *_p_ext__shared_ptrT_FittedBondDiscountCurve_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FittedBondDiscountCurve > *)x);
}
static void *_p_ext__shared_ptrT_FixedDividend_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FixedDividend > *)x);
}
static void *_p_ext__shared_ptrT_FixedLocalVolSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FixedLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FixedRateBond > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondForward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FixedRateBondForward > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FixedRateBondHelper > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FixedRateCoupon > *)x);
}
static void *_p_ext__shared_ptrT_FlatForward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FlatForward > *)x);
}
static void *_p_ext__shared_ptrT_FlatHazardRate_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FlatHazardRate > *)x);
}
static void *_p_ext__shared_ptrT_FlatSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FlatSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FloatFloatSwap > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwaption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FloatFloatSwaption > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FloatingRateBond > *)x);
}
static void *_p_ext__shared_ptrT_FloatingRateCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FloatingRateCoupon > *)x);
}
static void *_p_ext__shared_ptrT_Floor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Floor > *)x);
}
static void *_p_ext__shared_ptrT_Forward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Forward > *)x);
}
static void *_p_ext__shared_ptrT_ForwardEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ForwardEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_ForwardRateAgreement_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ForwardRateAgreement > *)x);
}
static void *_p_ext__shared_ptrT_ForwardSpreadedTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ForwardSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_FraRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FraRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_FractionalDividend_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FractionalDividend > *)x);
}
static void *_p_ext__shared_ptrT_FuturesRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FuturesRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_FxSwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< FxSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_G2_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< G2 > *)x);
}
static void *_p_ext__shared_ptrT_G2ForwardProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< G2ForwardProcess > *)x);
}
static void *_p_ext__shared_ptrT_G2Process_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< G2Process > *)x);
}
static void *_p_ext__shared_ptrT_G2SwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< G2SwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_GBPLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GBPLibor > *)x);
}
static void *_p_ext__shared_ptrT_GBPLiborON_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GBPLiborON > *)x);
}
static void *_p_ext__shared_ptrT_GJRGARCHModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GJRGARCHModel > *)x);
}
static void *_p_ext__shared_ptrT_GJRGARCHProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GJRGARCHProcess > *)x);
}
static void *_p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GarmanKohlagenProcess > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gaussian1dCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gaussian1dModel > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gaussian1dSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GbpLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GeneralizedBlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_GeometricBrownianMotionProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GeometricBrownianMotionProcess > *)x);
}
static void *_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GlobalLinearSimpleZeroCurve > *)x);
}
static void *_p_ext__shared_ptrT_GridModelLocalVolSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GridModelLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_Gsr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Gsr > *)x);
}
static void *_p_ext__shared_ptrT_GsrProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< GsrProcess > *)x);
}
static void *_p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HestonBlackVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_HestonModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HestonModel > *)x);
}
static void *_p_ext__shared_ptrT_HestonProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HestonProcess > *)x);
}
static void *_p_ext__shared_ptrT_HestonSLVProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HestonSLVProcess > *)x);
}
static void *_p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HimalayaOption > *)x);
}
static void *_p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HullWhite > *)x);
}
static void *_p_ext__shared_ptrT_HullWhiteForwardProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HullWhiteForwardProcess > *)x);
}
static void *_p_ext__shared_ptrT_HullWhiteProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< HullWhiteProcess > *)x);
}
static void *_p_ext__shared_ptrT_IborCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IborCoupon > *)x);
}
static void *_p_ext__shared_ptrT_IborIborBasisSwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IborIborBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_IborIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IborIndex > *)x);
}
static void *_p_ext__shared_ptrT_ImpliedTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ImpliedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Index_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Index > *)x);
}
static void *_p_ext__shared_ptrT_IndexedCashFlow_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IndexedCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_InflationCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_InflationIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_InflationTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Instrument_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Instrument > *)x);
}
static void *_p_ext__shared_ptrT_IntegralCdsEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IntegralCdsEngine > *)x);
}
static void *_p_ext__shared_ptrT_IntegralEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IntegralEngine > *)x);
}
static void *_p_ext__shared_ptrT_InterestRateIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterestRateIndex > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedSmileSection< Cubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedSmileSection< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< Kruger > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_IsdaCdsEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< IsdaCdsEngine > *)x);
}
static void *_p_ext__shared_ptrT_JPYLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< JPYLibor > *)x);
}
static void *_p_ext__shared_ptrT_JamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< JamshidianSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Jibar_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Jibar > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< JpyLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< JpyLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_JuQuadraticApproximationEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< JuQuadraticApproximationEngine > *)x);
}
static void *_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_KahaleSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< KahaleSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_KirkEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< KirkEngine > *)x);
}
static void *_p_ext__shared_ptrT_KirkSpreadOptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< KirkSpreadOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_KlugeExtOUProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< KlugeExtOUProcess > *)x);
}
static void *_p_ext__shared_ptrT_LastFixingQuote_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< LastFixingQuote > *)x);
}
static void *_p_ext__shared_ptrT_LazyObject_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< LazyObject > *)x);
}
static void *_p_ext__shared_ptrT_Libor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Libor > *)x);
}
static void *_p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< LocalConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< LocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< LocalVolTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCAmericanEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCBarrierEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDigitalEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDigitalEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDigitalEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDigitalEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCEverestEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCForwardEuropeanBSEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCForwardEuropeanBSEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCForwardEuropeanHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCForwardEuropeanHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCPerformanceEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCPerformanceEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCPerformanceEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MCPerformanceEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MargrabeOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MargrabeOption > *)x);
}
static void *_p_ext__shared_ptrT_MarkovFunctional_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MarkovFunctional > *)x);
}
static void *_p_ext__shared_ptrT_Merton76Process_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Merton76Process > *)x);
}
static void *_p_ext__shared_ptrT_MidPointCdsEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MidPointCdsEngine > *)x);
}
static void *_p_ext__shared_ptrT_Mosprime_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Mosprime > *)x);
}
static void *_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< MultiAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_NZDLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< NZDLibor > *)x);
}
static void *_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< NoArbSabrInterpolatedSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_NoArbSabrSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< NoArbSabrSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< NoExceptLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< NonstandardSwap > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwaption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< NonstandardSwaption > *)x);
}
static void *_p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Nzocr > *)x);
}
static void *_p_ext__shared_ptrT_OISRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OISRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OneAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_OneFactorAffineModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OneFactorAffineModel > *)x);
}
static void *_p_ext__shared_ptrT_Option_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Option > *)x);
}
static void *_p_ext__shared_ptrT_OptionletVolatilityStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OptionletVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OrnsteinUhlenbeckProcess > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIborBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIndex > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexFuture_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIndexFuture > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIndexFutureRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIndexedCoupon > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIndexedSwap > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< OvernightIndexedSwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_PartialTimeBarrierOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PartialTimeBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseConvexMonotoneForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseConvexMonotoneZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseCubicZero_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseCubicZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseFlatForward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseFlatForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseFlatHazardRate_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseFlatHazardRate > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseKrugerLogDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseKrugerZero_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseKrugerZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLinearForward_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseLinearForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLinearZero_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseLinearZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseLogCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseLogLinearDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseNaturalCubicZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseSplineCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseTimeDependentHestonModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseTimeDependentHestonModel > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Pribor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Pribor > *)x);
}
static void *_p_ext__shared_ptrT_PricingEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< PricingEngine > *)x);
}
static void *_p_ext__shared_ptrT_QdFpAmericanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QdFpAmericanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QdPlusAmericanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QdPlusAmericanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoDoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoForwardEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< QuantoVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_Quote_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Quote > *)x);
}
static void *_p_ext__shared_ptrT_RateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< RateHelper > *)x);
}
static void *_p_ext__shared_ptrT_Redemption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Redemption > *)x);
}
static void *_p_ext__shared_ptrT_RiskyBondEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< RiskyBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_Robor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Robor > *)x);
}
static void *_p_ext__shared_ptrT_SEKLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SEKLibor > *)x);
}
static void *_p_ext__shared_ptrT_SabrSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SabrSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SabrSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_Shibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Shibor > *)x);
}
static void *_p_ext__shared_ptrT_ShortRateModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ShortRateModel > *)x);
}
static void *_p_ext__shared_ptrT_SimpleCashFlow_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SimpleCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_SimpleChooserOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SimpleChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_SimpleQuote_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SimpleQuote > *)x);
}
static void *_p_ext__shared_ptrT_SmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SmileSection > *)x);
}
static void *_p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Sofr > *)x);
}
static void *_p_ext__shared_ptrT_SofrFutureRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SofrFutureRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Sonia > *)x);
}
static void *_p_ext__shared_ptrT_SpreadCdsHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SpreadCdsHelper > *)x);
}
static void *_p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SpreadOption > *)x);
}
static void *_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_StochasticProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< StochasticProcess > *)x);
}
static void *_p_ext__shared_ptrT_StochasticProcess1D_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< StochasticProcess1D > *)x);
}
static void *_p_ext__shared_ptrT_StochasticProcessArray_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< StochasticProcessArray > *)x);
}
static void *_p_ext__shared_ptrT_Stock_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Stock > *)x);
}
static void *_p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< StrippedOptionletAdapter > *)x);
}
static void *_p_ext__shared_ptrT_StulzEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< StulzEngine > *)x);
}
static void *_p_ext__shared_ptrT_SubPeriodsCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SubPeriodsCoupon > *)x);
}
static void *_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SuoWangDoubleBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_SviInterpolatedSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SviInterpolatedSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_SviSmileSection_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SviSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_Swap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Swap > *)x);
}
static void *_p_ext__shared_ptrT_SwapIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_SwapRateHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_SwapSpreadIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwapSpreadIndex > *)x);
}
static void *_p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Swaption > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwaptionVolatilityDiscrete > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwaptionVolatilityMatrix > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< SwaptionVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_Swestr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Swestr > *)x);
}
static void *_p_ext__shared_ptrT_THBFIX_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< THBFIX > *)x);
}
static void *_p_ext__shared_ptrT_TRLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TRLibor > *)x);
}
static void *_p_ext__shared_ptrT_TermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TermStructure > *)x);
}
static void *_p_ext__shared_ptrT_TermStructureConsistentModel_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TermStructureConsistentModel > *)x);
}
static void *_p_ext__shared_ptrT_Tibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Tibor > *)x);
}
static void *_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TreeCallableFixedRateBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_TreeCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TreeCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_TreeSwaptionEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TreeSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_TurnbullWakemanAsianEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< TurnbullWakemanAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_UKHICP_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< UKHICP > *)x);
}
static void *_p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< UKRPI > *)x);
}
static void *_p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< USCPI > *)x);
}
static void *_p_ext__shared_ptrT_USDLibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< USDLibor > *)x);
}
static void *_p_ext__shared_ptrT_USDLiborON_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< USDLiborON > *)x);
}
static void *_p_ext__shared_ptrT_UltimateForwardTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< UltimateForwardTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_UpfrontCdsHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< UpfrontCdsHelper > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< UsdLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< UsdLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VanillaSwap > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VanillaSwingOption > *)x);
}
static void *_p_ext__shared_ptrT_VannaVolgaBarrierEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VannaVolgaBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > *)x);
}
static void *_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > > *)x);
}
static void *_p_ext__shared_ptrT_VarianceGammaEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VarianceGammaEngine > *)x);
}
static void *_p_ext__shared_ptrT_VarianceGammaProcess_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VarianceGammaProcess > *)x);
}
static void *_p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Vasicek > *)x);
}
static void *_p_ext__shared_ptrT_VolatilityTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< VolatilityTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Wibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Wibor > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYEUHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYEUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYEUHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYFRHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYFRHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYUKRPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYUKRPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYUSCPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYUSCPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYZACPI > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YYZACPIr > *)x);
}
static void *_p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YearOnYearInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_YearOnYearInflationSwapHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YearOnYearInflationSwapHelper > *)x);
}
static void *_p_ext__shared_ptrT_YieldTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YieldTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationBachelierCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationBlackCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationCap > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationCapFloor > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationCollar > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCoupon_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationFloor > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_YoYOptionletHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYOptionletHelper > *)x);
}
static void *_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< YoYOptionletVolatilitySurface > *)x);
}
static void *_p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZACPI > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponBond_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroCouponBond > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroCouponInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponInflationSwapHelper_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroCouponInflationSwapHelper > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponSwap_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroCouponSwap > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationCashFlow_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroInflationCashFlow > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationIndex_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroInflationIndex > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroInflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_ZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< ZeroSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Zibor_tTo_p_ext__shared_ptrT_Observable_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Observable >(*(ext::shared_ptr< Zibor > *)x);
}
static void *_p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< BarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_CliquetOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< CliquetOption > *)x);
}
static void *_p_ext__shared_ptrT_ComplexChooserOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ComplexChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_CompoundOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< CompoundOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ContinuousAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFixedLookbackOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ContinuousFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ContinuousFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< DiscreteAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< DividendBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< DividendVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< DoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< EuropeanOption > *)x);
}
static void *_p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< ForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_PartialTimeBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< PartialTimeBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< QuantoBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< QuantoDoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< QuantoForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< QuantoVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_SimpleChooserOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< SimpleChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< VanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_OneAssetOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneAssetOption >(*(ext::shared_ptr< VanillaSwingOption > *)x);
}
static void *_p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_OneFactorAffineModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneFactorAffineModel >(*(ext::shared_ptr< HullWhite > *)x);
}
static void *_p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_OneFactorAffineModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OneFactorAffineModel >(*(ext::shared_ptr< Vasicek > *)x);
}
static void *_p_ext__shared_ptrT_BFGS_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< BFGS > *)x);
}
static void *_p_ext__shared_ptrT_ConjugateGradient_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< ConjugateGradient > *)x);
}
static void *_p_ext__shared_ptrT_DifferentialEvolution_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< DifferentialEvolution > *)x);
}
static void *_p_ext__shared_ptrT_GaussianSimulatedAnnealing_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< GaussianSimulatedAnnealing > *)x);
}
static void *_p_ext__shared_ptrT_LevenbergMarquardt_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< LevenbergMarquardt > *)x);
}
static void *_p_ext__shared_ptrT_LogNormalSimulatedAnnealing_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< LogNormalSimulatedAnnealing > *)x);
}
static void *_p_ext__shared_ptrT_MirrorGaussianSimulatedAnnealing_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< MirrorGaussianSimulatedAnnealing > *)x);
}
static void *_p_ext__shared_ptrT_Simplex_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< Simplex > *)x);
}
static void *_p_ext__shared_ptrT_SteepestDescent_tTo_p_ext__shared_ptrT_OptimizationMethod_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptimizationMethod >(*(ext::shared_ptr< SteepestDescent > *)x);
}
static void *_p_ext__shared_ptrT_BarrierOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< BarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_BasketOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< BasketOption > *)x);
}
static void *_p_ext__shared_ptrT_CdsOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< CdsOption > *)x);
}
static void *_p_ext__shared_ptrT_CliquetOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< CliquetOption > *)x);
}
static void *_p_ext__shared_ptrT_ComplexChooserOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ComplexChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_CompoundOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< CompoundOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousAveragingAsianOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ContinuousAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFixedLookbackOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ContinuousFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousFloatingLookbackOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ContinuousFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFixedLookbackOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ContinuousPartialFixedLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousPartialFloatingLookbackOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ContinuousPartialFloatingLookbackOption > *)x);
}
static void *_p_ext__shared_ptrT_DiscreteAveragingAsianOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< DiscreteAveragingAsianOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendBarrierOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< DividendBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_DividendVanillaOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< DividendVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_DoubleBarrierOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< DoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< EuropeanOption > *)x);
}
static void *_p_ext__shared_ptrT_EverestOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< EverestOption > *)x);
}
static void *_p_ext__shared_ptrT_ForwardVanillaOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< ForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_HimalayaOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< HimalayaOption > *)x);
}
static void *_p_ext__shared_ptrT_MargrabeOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< MargrabeOption > *)x);
}
static void *_p_ext__shared_ptrT_MultiAssetOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< MultiAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_OneAssetOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< OneAssetOption > *)x);
}
static void *_p_ext__shared_ptrT_PartialTimeBarrierOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< PartialTimeBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< QuantoBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoDoubleBarrierOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< QuantoDoubleBarrierOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardVanillaOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< QuantoForwardVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_QuantoVanillaOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< QuantoVanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_SimpleChooserOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< SimpleChooserOption > *)x);
}
static void *_p_ext__shared_ptrT_SpreadOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< SpreadOption > *)x);
}
static void *_p_ext__shared_ptrT_Swaption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< Swaption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< VanillaOption > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwingOption_tTo_p_ext__shared_ptrT_Option_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Option >(*(ext::shared_ptr< VanillaSwingOption > *)x);
}
static void *_p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_OptionletVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptionletVolatilityStructure >(*(ext::shared_ptr< ConstantOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_OptionletVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OptionletVolatilityStructure >(*(ext::shared_ptr< StrippedOptionletAdapter > *)x);
}
static void *_p_ext__shared_ptrT_Aonia_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Aonia > *)x);
}
static void *_p_ext__shared_ptrT_Corra_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Corra > *)x);
}
static void *_p_ext__shared_ptrT_Destr_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Destr > *)x);
}
static void *_p_ext__shared_ptrT_Eonia_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Eonia > *)x);
}
static void *_p_ext__shared_ptrT_Estr_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Estr > *)x);
}
static void *_p_ext__shared_ptrT_FedFunds_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< FedFunds > *)x);
}
static void *_p_ext__shared_ptrT_Nzocr_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Nzocr > *)x);
}
static void *_p_ext__shared_ptrT_Sofr_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Sofr > *)x);
}
static void *_p_ext__shared_ptrT_Sonia_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Sonia > *)x);
}
static void *_p_ext__shared_ptrT_Swestr_tTo_p_ext__shared_ptrT_OvernightIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndex >(*(ext::shared_ptr< Swestr > *)x);
}
static void *_p_ext__shared_ptrT_SofrFutureRateHelper_tTo_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< OvernightIndexFutureRateHelper >(*(ext::shared_ptr< SofrFutureRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_AssetOrNothingPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< AssetOrNothingPayoff > *)x);
}
static void *_p_ext__shared_ptrT_AverageBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< AverageBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_BasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< BasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_CashOrNothingPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< CashOrNothingPayoff > *)x);
}
static void *_p_ext__shared_ptrT_FloatingTypePayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< FloatingTypePayoff > *)x);
}
static void *_p_ext__shared_ptrT_GapPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< GapPayoff > *)x);
}
static void *_p_ext__shared_ptrT_MaxBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< MaxBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_MinBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< MinBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_PercentageStrikePayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< PercentageStrikePayoff > *)x);
}
static void *_p_ext__shared_ptrT_PlainVanillaPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< PlainVanillaPayoff > *)x);
}
static void *_p_ext__shared_ptrT_SpreadBasketPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< SpreadBasketPayoff > *)x);
}
static void *_p_ext__shared_ptrT_StrikedTypePayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< StrikedTypePayoff > *)x);
}
static void *_p_ext__shared_ptrT_SuperSharePayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< SuperSharePayoff > *)x);
}
static void *_p_ext__shared_ptrT_TypePayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< TypePayoff > *)x);
}
static void *_p_ext__shared_ptrT_VanillaForwardPayoff_tTo_p_ext__shared_ptrT_Payoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Payoff >(*(ext::shared_ptr< VanillaForwardPayoff > *)x);
}
static void *_p_ext__shared_ptrT_ExponentialForwardCorrelation_tTo_p_ext__shared_ptrT_PiecewiseConstantCorrelation_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PiecewiseConstantCorrelation >(*(ext::shared_ptr< ExponentialForwardCorrelation > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticAmericanMargrabeEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticAmericanMargrabeEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticBSMHullWhiteEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticBSMHullWhiteEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticBinaryBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticBinaryBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCEVEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticCEVEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCliquetEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticCliquetEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticComplexChooserEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticComplexChooserEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticCompoundOptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticCompoundOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousFixedLookbackEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticContinuousFixedLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousFloatingLookbackEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticContinuousFloatingLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousGeometricAveragePriceAsianHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticContinuousGeometricAveragePriceAsianHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousPartialFixedLookbackEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticContinuousPartialFixedLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticContinuousPartialFloatingLookbackEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticContinuousPartialFloatingLookbackEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDigitalAmericanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDigitalAmericanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDigitalAmericanKOEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDigitalAmericanKOEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDiscreteGeometricAveragePriceAsianHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDiscreteGeometricAverageStrikeAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDiscreteGeometricAverageStrikeAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDividendEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDividendEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDoubleBarrierBinaryEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDoubleBarrierBinaryEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticDoubleBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticDoubleBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticEuropeanMargrabeEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticEuropeanMargrabeEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticGJRGARCHEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticGJRGARCHEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticH1HWEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticH1HWEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHestonForwardEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticHestonForwardEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticHestonHullWhiteEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticHestonHullWhiteEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticPTDHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticPTDHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticPartialTimeBarrierOptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticPartialTimeBarrierOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticPerformanceEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticPerformanceEngine > *)x);
}
static void *_p_ext__shared_ptrT_AnalyticSimpleChooserEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< AnalyticSimpleChooserEngine > *)x);
}
static void *_p_ext__shared_ptrT_BachelierCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BachelierCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_BachelierSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BachelierSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_BaroneAdesiWhaleyApproximationEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BaroneAdesiWhaleyApproximationEngine > *)x);
}
static void *_p_ext__shared_ptrT_BatesEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BatesEngine > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_JarrowRudd_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< JarrowRudd,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_Joshi4_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< Joshi4,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_LeisenReimer_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< LeisenReimer,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_Tian_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< Tian,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialBarrierEngineT_Trigeorgis_DiscretizedDermanKaniBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialBarrierEngine< Trigeorgis,DiscretizedDermanKaniBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< AdditiveEQPBinomialTree > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< CoxRossRubinstein > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< JarrowRudd > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< Joshi4 > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< LeisenReimer > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_Tian_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< Tian > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialConvertibleEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialConvertibleEngine< Trigeorgis > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_AdditiveEQPBinomialTree_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< AdditiveEQPBinomialTree,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_CoxRossRubinstein_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< CoxRossRubinstein,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_JarrowRudd_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< JarrowRudd,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Joshi4_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< Joshi4,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_LeisenReimer_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< LeisenReimer,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Tian_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< Tian,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialDoubleBarrierEngineT_Trigeorgis_DiscretizedDermanKaniDoubleBarrierOption_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialDoubleBarrierEngine< Trigeorgis,DiscretizedDermanKaniDoubleBarrierOption > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_AdditiveEQPBinomialTree_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< AdditiveEQPBinomialTree > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_CoxRossRubinstein_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< CoxRossRubinstein > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_JarrowRudd_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< JarrowRudd > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_Joshi4_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< Joshi4 > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_LeisenReimer_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< LeisenReimer > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_Tian_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< Tian > > *)x);
}
static void *_p_ext__shared_ptrT_BinomialVanillaEngineT_Trigeorgis_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BinomialVanillaEngine< Trigeorgis > > *)x);
}
static void *_p_ext__shared_ptrT_BjerksundStenslandApproximationEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BjerksundStenslandApproximationEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BlackCallableFixedRateBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BlackCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackCdsOptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BlackCdsOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_BlackSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< BlackSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_COSHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< COSHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_ContinuousArithmeticAsianLevyEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< ContinuousArithmeticAsianLevyEngine > *)x);
}
static void *_p_ext__shared_ptrT_DiscountingBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< DiscountingBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_DiscountingSwapEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< DiscountingSwapEngine > *)x);
}
static void *_p_ext__shared_ptrT_ExponentialFittingHestonEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< ExponentialFittingHestonEngine > *)x);
}
static void *_p_ext__shared_ptrT_FFTVarianceGammaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FFTVarianceGammaEngine > *)x);
}
static void *_p_ext__shared_ptrT_Fd2dBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< Fd2dBlackScholesVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBatesVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdBatesVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdBlackScholesAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdBlackScholesBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesRebateEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdBlackScholesRebateEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesShoutEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdBlackScholesShoutEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdBlackScholesVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdBlackScholesVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdCEVVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdCEVVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdG2SwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdG2SwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdHestonBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonDoubleBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdHestonDoubleBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonHullWhiteVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdHestonHullWhiteVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonRebateEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdHestonRebateEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHestonVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdHestonVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdHullWhiteSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdHullWhiteSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdOrnsteinUhlenbeckVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdOrnsteinUhlenbeckVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdSabrVanillaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdSabrVanillaEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdSimpleBSSwingEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdSimpleBSSwingEngine > *)x);
}
static void *_p_ext__shared_ptrT_FdSimpleExtOUJumpSwingEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< FdSimpleExtOUJumpSwingEngine > *)x);
}
static void *_p_ext__shared_ptrT_ForwardEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< ForwardEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_G2SwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< G2SwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< Gaussian1dCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dFloatFloatSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< Gaussian1dFloatFloatSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dJamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< Gaussian1dJamshidianSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dNonstandardSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< Gaussian1dNonstandardSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< Gaussian1dSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_IntegralCdsEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< IntegralCdsEngine > *)x);
}
static void *_p_ext__shared_ptrT_IntegralEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< IntegralEngine > *)x);
}
static void *_p_ext__shared_ptrT_IsdaCdsEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< IsdaCdsEngine > *)x);
}
static void *_p_ext__shared_ptrT_JamshidianSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< JamshidianSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_JuQuadraticApproximationEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< JuQuadraticApproximationEngine > *)x);
}
static void *_p_ext__shared_ptrT_KirkEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< KirkEngine > *)x);
}
static void *_p_ext__shared_ptrT_KirkSpreadOptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< KirkSpreadOptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCAmericanBasketEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCAmericanBasketEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCAmericanEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCAmericanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCAmericanEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCBarrierEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCBarrierEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCBarrierEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCBarrierEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDigitalEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDigitalEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDigitalEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDigitalEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteArithmeticAPEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteArithmeticAPEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticAPHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteArithmeticAPHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteArithmeticASEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteArithmeticASEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteArithmeticASEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteGeometricAPEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteGeometricAPEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCDiscreteGeometricAPHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCDiscreteGeometricAPHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanBasketEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanBasketEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanBasketEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanBasketEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanGJRGARCHEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanGJRGARCHEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanGJRGARCHEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEuropeanHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEuropeanHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCEverestEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEverestEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCEverestEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCEverestEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCForwardEuropeanBSEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanBSEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCForwardEuropeanBSEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCForwardEuropeanHestonEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCForwardEuropeanHestonEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCForwardEuropeanHestonEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCHimalayaEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCHimalayaEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCHimalayaEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCHimalayaEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MCPerformanceEngineT_LowDiscrepancy_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCPerformanceEngine< LowDiscrepancy > > *)x);
}
static void *_p_ext__shared_ptrT_MCPerformanceEngineT_PseudoRandom_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MCPerformanceEngine< PseudoRandom > > *)x);
}
static void *_p_ext__shared_ptrT_MidPointCdsEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< MidPointCdsEngine > *)x);
}
static void *_p_ext__shared_ptrT_QdFpAmericanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< QdFpAmericanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QdPlusAmericanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< QdPlusAmericanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< QuantoBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< QuantoEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_QuantoForwardEuropeanEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< QuantoForwardEuropeanEngine > *)x);
}
static void *_p_ext__shared_ptrT_RiskyBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< RiskyBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_StulzEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< StulzEngine > *)x);
}
static void *_p_ext__shared_ptrT_SuoWangDoubleBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< SuoWangDoubleBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_TreeCallableFixedRateBondEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< TreeCallableFixedRateBondEngine > *)x);
}
static void *_p_ext__shared_ptrT_TreeCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< TreeCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_TreeSwaptionEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< TreeSwaptionEngine > *)x);
}
static void *_p_ext__shared_ptrT_TurnbullWakemanAsianEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< TurnbullWakemanAsianEngine > *)x);
}
static void *_p_ext__shared_ptrT_VannaVolgaBarrierEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< VannaVolgaBarrierEngine > *)x);
}
static void *_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_AnalyticDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< VannaVolgaDoubleBarrierEngine< AnalyticDoubleBarrierEngine > > *)x);
}
static void *_p_ext__shared_ptrT_VannaVolgaDoubleBarrierEngineT_SuoWangDoubleBarrierEngine_t_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< VannaVolgaDoubleBarrierEngine< SuoWangDoubleBarrierEngine > > *)x);
}
static void *_p_ext__shared_ptrT_VarianceGammaEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< VarianceGammaEngine > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationBachelierCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< YoYInflationBachelierCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationBlackCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< YoYInflationBlackCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationUnitDisplacedBlackCapFloorEngine_tTo_p_ext__shared_ptrT_PricingEngine_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< PricingEngine >(*(ext::shared_ptr< YoYInflationUnitDisplacedBlackCapFloorEngine > *)x);
}
static void *_p_ext__shared_ptrT_QdFpLegendreScheme_tTo_p_ext__shared_ptrT_QdFpIterationScheme_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< QdFpIterationScheme >(*(ext::shared_ptr< QdFpLegendreScheme > *)x);
}
static void *_p_ext__shared_ptrT_QdFpLegendreTanhSinhScheme_tTo_p_ext__shared_ptrT_QdFpIterationScheme_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< QdFpIterationScheme >(*(ext::shared_ptr< QdFpLegendreTanhSinhScheme > *)x);
}
static void *_p_ext__shared_ptrT_QdFpTanhSinhIterationScheme_tTo_p_ext__shared_ptrT_QdFpIterationScheme_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< QdFpIterationScheme >(*(ext::shared_ptr< QdFpTanhSinhIterationScheme > *)x);
}
static void *_p_ext__shared_ptrT_QdFpLegendreTanhSinhScheme_tTo_p_ext__shared_ptrT_QdFpLegendreScheme_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< QdFpLegendreScheme >(*(ext::shared_ptr< QdFpLegendreTanhSinhScheme > *)x);
}
static void *_p_ext__shared_ptrT_CompositeQuoteT_BinaryFunction_t_tTo_p_ext__shared_ptrT_Quote_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Quote >(*(ext::shared_ptr< CompositeQuote< BinaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_DeltaVolQuote_tTo_p_ext__shared_ptrT_Quote_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Quote >(*(ext::shared_ptr< DeltaVolQuote > *)x);
}
static void *_p_ext__shared_ptrT_DerivedQuoteT_UnaryFunction_t_tTo_p_ext__shared_ptrT_Quote_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Quote >(*(ext::shared_ptr< DerivedQuote< UnaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_LastFixingQuote_tTo_p_ext__shared_ptrT_Quote_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Quote >(*(ext::shared_ptr< LastFixingQuote > *)x);
}
static void *_p_ext__shared_ptrT_SimpleQuote_tTo_p_ext__shared_ptrT_Quote_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Quote >(*(ext::shared_ptr< SimpleQuote > *)x);
}
static void *_p_ext__shared_ptrT_ArithmeticOISRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< ArithmeticOISRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_BondHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< BondHelper > *)x);
}
static void *_p_ext__shared_ptrT_ConstNotionalCrossCurrencyBasisSwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< ConstNotionalCrossCurrencyBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_DatedOISRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< DatedOISRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_DepositRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< DepositRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_FixedRateBondHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< FixedRateBondHelper > *)x);
}
static void *_p_ext__shared_ptrT_FraRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< FraRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_FuturesRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< FuturesRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_FxSwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< FxSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_IborIborBasisSwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< IborIborBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_MtMCrossCurrencyBasisSwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< MtMCrossCurrencyBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_OISRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< OISRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIborBasisSwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< OvernightIborBasisSwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexFutureRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< OvernightIndexFutureRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_SofrFutureRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< SofrFutureRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_SwapRateHelper_tTo_p_ext__shared_ptrT_RateHelper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RateHelper >(*(ext::shared_ptr< SwapRateHelper > *)x);
}
static void *_p_ext__shared_ptrT_BSMRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RiskNeutralDensityCalculator >(*(ext::shared_ptr< BSMRNDCalculator > *)x);
}
static void *_p_ext__shared_ptrT_CEVRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RiskNeutralDensityCalculator >(*(ext::shared_ptr< CEVRNDCalculator > *)x);
}
static void *_p_ext__shared_ptrT_GBSMRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RiskNeutralDensityCalculator >(*(ext::shared_ptr< GBSMRNDCalculator > *)x);
}
static void *_p_ext__shared_ptrT_HestonRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RiskNeutralDensityCalculator >(*(ext::shared_ptr< HestonRNDCalculator > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RiskNeutralDensityCalculator >(*(ext::shared_ptr< LocalVolRNDCalculator > *)x);
}
static void *_p_ext__shared_ptrT_SquareRootProcessRNDCalculator_tTo_p_ext__shared_ptrT_RiskNeutralDensityCalculator_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< RiskNeutralDensityCalculator >(*(ext::shared_ptr< SquareRootProcessRNDCalculator > *)x);
}
static void *_p_ext__shared_ptrT_KerkhofSeasonality_tTo_p_ext__shared_ptrT_Seasonality_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Seasonality >(*(ext::shared_ptr< KerkhofSeasonality > *)x);
}
static void *_p_ext__shared_ptrT_MultiplicativePriceSeasonality_tTo_p_ext__shared_ptrT_Seasonality_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Seasonality >(*(ext::shared_ptr< MultiplicativePriceSeasonality > *)x);
}
static void *_p_ext__shared_ptrT_BlackKarasinski_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< BlackKarasinski > *)x);
}
static void *_p_ext__shared_ptrT_CoxIngersollRoss_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< CoxIngersollRoss > *)x);
}
static void *_p_ext__shared_ptrT_ExtendedCoxIngersollRoss_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< ExtendedCoxIngersollRoss > *)x);
}
static void *_p_ext__shared_ptrT_G2_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< G2 > *)x);
}
static void *_p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< HullWhite > *)x);
}
static void *_p_ext__shared_ptrT_OneFactorAffineModel_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< OneFactorAffineModel > *)x);
}
static void *_p_ext__shared_ptrT_Vasicek_tTo_p_ext__shared_ptrT_ShortRateModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ShortRateModel >(*(ext::shared_ptr< Vasicek > *)x);
}
static void *_p_ext__shared_ptrT_FlatSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< FlatSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_Cubic_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< InterpolatedSmileSection< Cubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_Linear_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< InterpolatedSmileSection< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< InterpolatedSmileSection< MonotonicCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSmileSectionT_SplineCubic_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< InterpolatedSmileSection< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_KahaleSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< KahaleSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_NoArbSabrInterpolatedSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< NoArbSabrInterpolatedSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_NoArbSabrSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< NoArbSabrSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_SabrSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< SabrSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_SviInterpolatedSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< SviInterpolatedSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_SviSmileSection_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< SviSmileSection > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrFullFd > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrLocalVolatility > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityLognormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrInterpolatedSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrInterpolatedSmileSection< ZabrShortMaturityNormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrFullFd_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrSmileSection< ZabrFullFd > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrLocalVolatility_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrSmileSection< ZabrLocalVolatility > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityLognormal_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityLognormal > > *)x);
}
static void *_p_ext__shared_ptrT_ZabrSmileSectionT_ZabrShortMaturityNormal_t_tTo_p_ext__shared_ptrT_SmileSection_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SmileSection >(*(ext::shared_ptr< ZabrSmileSection< ZabrShortMaturityNormal > > *)x);
}
static void *_p_ext__shared_ptrT_FdmAmericanStepCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmAmericanStepCondition > *)x);
}
static void *_p_ext__shared_ptrT_FdmArithmeticAverageCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmArithmeticAverageCondition > *)x);
}
static void *_p_ext__shared_ptrT_FdmBermudanStepCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmBermudanStepCondition > *)x);
}
static void *_p_ext__shared_ptrT_FdmDividendHandler_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmDividendHandler > *)x);
}
static void *_p_ext__shared_ptrT_FdmSimpleStorageCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmSimpleStorageCondition > *)x);
}
static void *_p_ext__shared_ptrT_FdmSimpleSwingCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmSimpleSwingCondition > *)x);
}
static void *_p_ext__shared_ptrT_FdmSnapshotCondition_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmSnapshotCondition > *)x);
}
static void *_p_ext__shared_ptrT_FdmStepConditionComposite_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmStepConditionComposite > *)x);
}
static void *_p_ext__shared_ptrT_FdmStepConditionProxy_tTo_p_ext__shared_ptrT_StepConditionT_Array_t_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StepCondition< Array > >(*(ext::shared_ptr< FdmStepConditionProxy > *)x);
}
static void *_p_ext__shared_ptrT_BatesProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< BatesProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< BlackProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< BlackScholesMertonProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< BlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_ExtOUWithJumpsProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< ExtOUWithJumpsProcess > *)x);
}
static void *_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *)x);
}
static void *_p_ext__shared_ptrT_G2ForwardProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< G2ForwardProcess > *)x);
}
static void *_p_ext__shared_ptrT_G2Process_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< G2Process > *)x);
}
static void *_p_ext__shared_ptrT_GJRGARCHProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< GJRGARCHProcess > *)x);
}
static void *_p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< GarmanKohlagenProcess > *)x);
}
static void *_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< GeneralizedBlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_GeometricBrownianMotionProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< GeometricBrownianMotionProcess > *)x);
}
static void *_p_ext__shared_ptrT_GsrProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< GsrProcess > *)x);
}
static void *_p_ext__shared_ptrT_HestonProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< HestonProcess > *)x);
}
static void *_p_ext__shared_ptrT_HestonSLVProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< HestonSLVProcess > *)x);
}
static void *_p_ext__shared_ptrT_HullWhiteForwardProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< HullWhiteForwardProcess > *)x);
}
static void *_p_ext__shared_ptrT_HullWhiteProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< HullWhiteProcess > *)x);
}
static void *_p_ext__shared_ptrT_KlugeExtOUProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< KlugeExtOUProcess > *)x);
}
static void *_p_ext__shared_ptrT_Merton76Process_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< Merton76Process > *)x);
}
static void *_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< OrnsteinUhlenbeckProcess > *)x);
}
static void *_p_ext__shared_ptrT_StochasticProcess1D_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< StochasticProcess1D > *)x);
}
static void *_p_ext__shared_ptrT_StochasticProcessArray_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< StochasticProcessArray > *)x);
}
static void *_p_ext__shared_ptrT_VarianceGammaProcess_tTo_p_ext__shared_ptrT_StochasticProcess_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess >(*(ext::shared_ptr< VarianceGammaProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< BlackProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesMertonProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< BlackScholesMertonProcess > *)x);
}
static void *_p_ext__shared_ptrT_BlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< BlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_ExtendedOrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< ExtendedOrnsteinUhlenbeckProcess > *)x);
}
static void *_p_ext__shared_ptrT_GarmanKohlagenProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< GarmanKohlagenProcess > *)x);
}
static void *_p_ext__shared_ptrT_GeneralizedBlackScholesProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< GeneralizedBlackScholesProcess > *)x);
}
static void *_p_ext__shared_ptrT_GeometricBrownianMotionProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< GeometricBrownianMotionProcess > *)x);
}
static void *_p_ext__shared_ptrT_GsrProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< GsrProcess > *)x);
}
static void *_p_ext__shared_ptrT_HullWhiteForwardProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< HullWhiteForwardProcess > *)x);
}
static void *_p_ext__shared_ptrT_HullWhiteProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< HullWhiteProcess > *)x);
}
static void *_p_ext__shared_ptrT_Merton76Process_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< Merton76Process > *)x);
}
static void *_p_ext__shared_ptrT_OrnsteinUhlenbeckProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< OrnsteinUhlenbeckProcess > *)x);
}
static void *_p_ext__shared_ptrT_VarianceGammaProcess_tTo_p_ext__shared_ptrT_StochasticProcess1D_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StochasticProcess1D >(*(ext::shared_ptr< VarianceGammaProcess > *)x);
}
static void *_p_ext__shared_ptrT_AssetOrNothingPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< AssetOrNothingPayoff > *)x);
}
static void *_p_ext__shared_ptrT_CashOrNothingPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< CashOrNothingPayoff > *)x);
}
static void *_p_ext__shared_ptrT_GapPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< GapPayoff > *)x);
}
static void *_p_ext__shared_ptrT_PercentageStrikePayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< PercentageStrikePayoff > *)x);
}
static void *_p_ext__shared_ptrT_PlainVanillaPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< PlainVanillaPayoff > *)x);
}
static void *_p_ext__shared_ptrT_SuperSharePayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< SuperSharePayoff > *)x);
}
static void *_p_ext__shared_ptrT_VanillaForwardPayoff_tTo_p_ext__shared_ptrT_StrikedTypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrikedTypePayoff >(*(ext::shared_ptr< VanillaForwardPayoff > *)x);
}
static void *_p_ext__shared_ptrT_OptionletStripper1_tTo_p_ext__shared_ptrT_StrippedOptionletBase_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrippedOptionletBase >(*(ext::shared_ptr< OptionletStripper1 > *)x);
}
static void *_p_ext__shared_ptrT_StrippedOptionlet_tTo_p_ext__shared_ptrT_StrippedOptionletBase_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< StrippedOptionletBase >(*(ext::shared_ptr< StrippedOptionlet > *)x);
}
static void *_p_ext__shared_ptrT_AveragingRatePricer_tTo_p_ext__shared_ptrT_SubPeriodsPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SubPeriodsPricer >(*(ext::shared_ptr< AveragingRatePricer > *)x);
}
static void *_p_ext__shared_ptrT_CompoundingRatePricer_tTo_p_ext__shared_ptrT_SubPeriodsPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SubPeriodsPricer >(*(ext::shared_ptr< CompoundingRatePricer > *)x);
}
static void *_p_ext__shared_ptrT_ArithmeticAverageOIS_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< ArithmeticAverageOIS > *)x);
}
static void *_p_ext__shared_ptrT_AssetSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< AssetSwap > *)x);
}
static void *_p_ext__shared_ptrT_CPISwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< CPISwap > *)x);
}
static void *_p_ext__shared_ptrT_EquityTotalReturnSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< EquityTotalReturnSwap > *)x);
}
static void *_p_ext__shared_ptrT_FloatFloatSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< FloatFloatSwap > *)x);
}
static void *_p_ext__shared_ptrT_NonstandardSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< NonstandardSwap > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< OvernightIndexedSwap > *)x);
}
static void *_p_ext__shared_ptrT_VanillaSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< VanillaSwap > *)x);
}
static void *_p_ext__shared_ptrT_YearOnYearInflationSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< YearOnYearInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponInflationSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< ZeroCouponInflationSwap > *)x);
}
static void *_p_ext__shared_ptrT_ZeroCouponSwap_tTo_p_ext__shared_ptrT_Swap_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Swap >(*(ext::shared_ptr< ZeroCouponSwap > *)x);
}
static void *_p_ext__shared_ptrT_ChfLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< ChfLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIfrFix_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< EurLiborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixA_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< EurLiborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EurLiborSwapIsdaFixB_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< EurLiborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIfrFix_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< EuriborSwapIfrFix > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixA_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< EuriborSwapIsdaFixA > *)x);
}
static void *_p_ext__shared_ptrT_EuriborSwapIsdaFixB_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< EuriborSwapIsdaFixB > *)x);
}
static void *_p_ext__shared_ptrT_GbpLiborSwapIsdaFix_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< GbpLiborSwapIsdaFix > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< JpyLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_JpyLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< JpyLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_OvernightIndexedSwapIndex_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< OvernightIndexedSwapIndex > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixAm_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< UsdLiborSwapIsdaFixAm > *)x);
}
static void *_p_ext__shared_ptrT_UsdLiborSwapIsdaFixPm_tTo_p_ext__shared_ptrT_SwapIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwapIndex >(*(ext::shared_ptr< UsdLiborSwapIsdaFixPm > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityCube_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityCube >(*(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityCube_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityCube >(*(ext::shared_ptr< SabrSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityDiscrete >(*(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityDiscrete >(*(ext::shared_ptr< SabrSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityDiscrete >(*(ext::shared_ptr< SwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityDiscrete >(*(ext::shared_ptr< SwaptionVolatilityMatrix > *)x);
}
static void *_p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityStructure >(*(ext::shared_ptr< ConstantSwaptionVolatility > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityStructure >(*(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityStructure >(*(ext::shared_ptr< SabrSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityStructure >(*(ext::shared_ptr< SwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityStructure >(*(ext::shared_ptr< SwaptionVolatilityDiscrete > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_SwaptionVolatilityStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< SwaptionVolatilityStructure >(*(ext::shared_ptr< SwaptionVolatilityMatrix > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< AndreasenHugeLocalVolAdapter > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< AndreasenHugeVolatilityAdapter > *)x);
}
static void *_p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< BlackConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< BlackVarianceCurve > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< BlackVarianceSurface > *)x);
}
static void *_p_ext__shared_ptrT_BlackVolTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< BlackVolTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< CapFloorTermVolCurve > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< CapFloorTermVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< CapFloorTermVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< CompositeZeroYieldStructure< BinaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ConstantOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ConstantSwaptionVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ConstantYoYOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_DefaultProbabilityTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< DefaultProbabilityTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_FittedBondDiscountCurve_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< FittedBondDiscountCurve > *)x);
}
static void *_p_ext__shared_ptrT_FixedLocalVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< FixedLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_FlatForward_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< FlatForward > *)x);
}
static void *_p_ext__shared_ptrT_FlatHazardRate_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< FlatHazardRate > *)x);
}
static void *_p_ext__shared_ptrT_ForwardSpreadedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ForwardSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< GlobalLinearSimpleZeroCurve > *)x);
}
static void *_p_ext__shared_ptrT_GridModelLocalVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< GridModelLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< HestonBlackVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_ImpliedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ImpliedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_InflationTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDefaultDensityCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDefaultDensityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedHazardRateCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedHazardRateCurve< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSurvivalProbabilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedSurvivalProbabilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< Kruger > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< LocalConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< LocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< LocalVolTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< NoExceptLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_OptionletVolatilityStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< OptionletVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseConvexMonotoneForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseConvexMonotoneZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseCubicZero_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseCubicZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseFlatForward_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseFlatForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseFlatHazardRate_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseFlatHazardRate > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseKrugerLogDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseKrugerZero_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseKrugerZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLinearForward_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseLinearForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLinearZero_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseLinearZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseLogCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseLogLinearDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseNaturalCubicZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseSplineCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_QuantoTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< QuantoTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SabrSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< StrippedOptionletAdapter > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SwaptionVolatilityDiscrete > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SwaptionVolatilityMatrix > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< SwaptionVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_UltimateForwardTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< UltimateForwardTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_VolatilityTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< VolatilityTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_YieldTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< YieldTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< YoYCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< YoYInflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< YoYOptionletVolatilitySurface > *)x);
}
static void *_p_ext__shared_ptrT_ZeroInflationTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ZeroInflationTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_ZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_TermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructure >(*(ext::shared_ptr< ZeroSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_Gaussian1dModel_tTo_p_ext__shared_ptrT_TermStructureConsistentModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructureConsistentModel >(*(ext::shared_ptr< Gaussian1dModel > *)x);
}
static void *_p_ext__shared_ptrT_Gsr_tTo_p_ext__shared_ptrT_TermStructureConsistentModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructureConsistentModel >(*(ext::shared_ptr< Gsr > *)x);
}
static void *_p_ext__shared_ptrT_MarkovFunctional_tTo_p_ext__shared_ptrT_TermStructureConsistentModel_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TermStructureConsistentModel >(*(ext::shared_ptr< MarkovFunctional > *)x);
}
static void *_p_ext__shared_ptrT_FirstDerivativeOp_tTo_p_ext__shared_ptrT_TripleBandLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TripleBandLinearOp >(*(ext::shared_ptr< FirstDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_SecondDerivativeOp_tTo_p_ext__shared_ptrT_TripleBandLinearOp_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TripleBandLinearOp >(*(ext::shared_ptr< SecondDerivativeOp > *)x);
}
static void *_p_ext__shared_ptrT_AssetOrNothingPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< AssetOrNothingPayoff > *)x);
}
static void *_p_ext__shared_ptrT_CashOrNothingPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< CashOrNothingPayoff > *)x);
}
static void *_p_ext__shared_ptrT_FloatingTypePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< FloatingTypePayoff > *)x);
}
static void *_p_ext__shared_ptrT_GapPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< GapPayoff > *)x);
}
static void *_p_ext__shared_ptrT_PercentageStrikePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< PercentageStrikePayoff > *)x);
}
static void *_p_ext__shared_ptrT_PlainVanillaPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< PlainVanillaPayoff > *)x);
}
static void *_p_ext__shared_ptrT_StrikedTypePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< StrikedTypePayoff > *)x);
}
static void *_p_ext__shared_ptrT_SuperSharePayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< SuperSharePayoff > *)x);
}
static void *_p_ext__shared_ptrT_VanillaForwardPayoff_tTo_p_ext__shared_ptrT_TypePayoff_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< TypePayoff >(*(ext::shared_ptr< VanillaForwardPayoff > *)x);
}
static void *_p_ext__shared_ptrT_EuropeanOption_tTo_p_ext__shared_ptrT_VanillaOption_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VanillaOption >(*(ext::shared_ptr< EuropeanOption > *)x);
}
static void *_p_ext__shared_ptrT_HullWhite_tTo_p_ext__shared_ptrT_Vasicek_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< Vasicek >(*(ext::shared_ptr< HullWhite > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeLocalVolAdapter_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< AndreasenHugeLocalVolAdapter > *)x);
}
static void *_p_ext__shared_ptrT_AndreasenHugeVolatilityAdapter_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< AndreasenHugeVolatilityAdapter > *)x);
}
static void *_p_ext__shared_ptrT_BlackConstantVol_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< BlackConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceCurve_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< BlackVarianceCurve > *)x);
}
static void *_p_ext__shared_ptrT_BlackVarianceSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< BlackVarianceSurface > *)x);
}
static void *_p_ext__shared_ptrT_BlackVolTermStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< BlackVolTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolCurve_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< CapFloorTermVolCurve > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< CapFloorTermVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_CapFloorTermVolatilityStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< CapFloorTermVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_ConstantOptionletVolatility_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< ConstantOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ConstantSwaptionVolatility_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< ConstantSwaptionVolatility > *)x);
}
static void *_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< ConstantYoYOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_FixedLocalVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< FixedLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_GridModelLocalVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< GridModelLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_HestonBlackVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< HestonBlackVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< InterpolatedSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_LocalConstantVol_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< LocalConstantVol > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< LocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_LocalVolTermStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< LocalVolTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_NoExceptLocalVolSurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< NoExceptLocalVolSurface > *)x);
}
static void *_p_ext__shared_ptrT_OptionletVolatilityStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< OptionletVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_SabrSwaptionVolatilityCube_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< SabrSwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_StrippedOptionletAdapter_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< StrippedOptionletAdapter > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityCube_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< SwaptionVolatilityCube > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityDiscrete_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< SwaptionVolatilityDiscrete > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityMatrix_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< SwaptionVolatilityMatrix > *)x);
}
static void *_p_ext__shared_ptrT_SwaptionVolatilityStructure_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< SwaptionVolatilityStructure > *)x);
}
static void *_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_tTo_p_ext__shared_ptrT_VolatilityTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< VolatilityTermStructure >(*(ext::shared_ptr< YoYOptionletVolatilitySurface > *)x);
}
static void *_p_ext__shared_ptrT_CompositeZeroYieldStructureT_BinaryFunction_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< CompositeZeroYieldStructure< BinaryFunction > > *)x);
}
static void *_p_ext__shared_ptrT_FittedBondDiscountCurve_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< FittedBondDiscountCurve > *)x);
}
static void *_p_ext__shared_ptrT_FlatForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< FlatForward > *)x);
}
static void *_p_ext__shared_ptrT_ForwardSpreadedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< ForwardSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_GlobalLinearSimpleZeroCurve_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< GlobalLinearSimpleZeroCurve > *)x);
}
static void *_p_ext__shared_ptrT_ImpliedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< ImpliedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_KrugerLog_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< KrugerLog > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< LogLinear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_LogMixedLinearCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< LogMixedLinearCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_MonotonicLogCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< MonotonicLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedDiscountCurveT_SplineLogCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedDiscountCurve< SplineLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedForwardCurveT_BackwardFlat_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedForwardCurve< BackwardFlat > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Cubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< Cubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_DefaultLogCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< DefaultLogCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Kruger_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< Kruger > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_Linear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_LogLinear_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< LogLinear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_MonotonicCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< MonotonicCubic > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroCurveT_SplineCubic_t_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< InterpolatedZeroCurve< SplineCubic > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseConvexMonotoneForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseConvexMonotoneForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseConvexMonotoneZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseConvexMonotoneZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseCubicZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseCubicZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseFlatForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseFlatForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseKrugerLogDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseKrugerLogDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseKrugerZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseKrugerZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLinearForward_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseLinearForward > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLinearZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseLinearZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogCubicDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseLogCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogLinearDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseLogLinearDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseLogMixedLinearCubicDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseLogMixedLinearCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseNaturalCubicZero_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseNaturalCubicZero > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseNaturalLogCubicDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseNaturalLogCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseSplineCubicDiscount_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseSplineCubicDiscount > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< PiecewiseZeroSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_QuantoTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< QuantoTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_SpreadedBackwardFlatZeroInterpolatedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< SpreadedBackwardFlatZeroInterpolatedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_SpreadedLinearZeroInterpolatedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< SpreadedLinearZeroInterpolatedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_UltimateForwardTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< UltimateForwardTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_ZeroSpreadedTermStructure_tTo_p_ext__shared_ptrT_YieldTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YieldTermStructure >(*(ext::shared_ptr< ZeroSpreadedTermStructure > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCapFloorTermPriceSurface_tTo_p_ext__shared_ptrT_YoYCapFloorTermPriceSurface_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYCapFloorTermPriceSurface >(*(ext::shared_ptr< YoYInflationCapFloorTermPriceSurface > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCap_tTo_p_ext__shared_ptrT_YoYInflationCapFloor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCapFloor >(*(ext::shared_ptr< YoYInflationCap > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationCollar_tTo_p_ext__shared_ptrT_YoYInflationCapFloor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCapFloor >(*(ext::shared_ptr< YoYInflationCollar > *)x);
}
static void *_p_ext__shared_ptrT_YoYInflationFloor_tTo_p_ext__shared_ptrT_YoYInflationCapFloor_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCapFloor >(*(ext::shared_ptr< YoYInflationFloor > *)x);
}
static void *_p_ext__shared_ptrT_CappedFlooredYoYInflationCoupon_tTo_p_ext__shared_ptrT_YoYInflationCoupon_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCoupon >(*(ext::shared_ptr< CappedFlooredYoYInflationCoupon > *)x);
}
static void *_p_ext__shared_ptrT_BachelierYoYInflationCouponPricer_tTo_p_ext__shared_ptrT_YoYInflationCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCouponPricer >(*(ext::shared_ptr< BachelierYoYInflationCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_BlackYoYInflationCouponPricer_tTo_p_ext__shared_ptrT_YoYInflationCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCouponPricer >(*(ext::shared_ptr< BlackYoYInflationCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_UnitDisplacedBlackYoYInflationCouponPricer_tTo_p_ext__shared_ptrT_YoYInflationCouponPricer_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationCouponPricer >(*(ext::shared_ptr< UnitDisplacedBlackYoYInflationCouponPricer > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICP_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYEUHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPXT_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYEUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_YYEUHICPr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYEUHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICP_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYFRHICP > *)x);
}
static void *_p_ext__shared_ptrT_YYFRHICPr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYFRHICPr > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPI_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYUKRPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUKRPIr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYUKRPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPI_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYUSCPI > *)x);
}
static void *_p_ext__shared_ptrT_YYUSCPIr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYUSCPIr > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPI_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYZACPI > *)x);
}
static void *_p_ext__shared_ptrT_YYZACPIr_tTo_p_ext__shared_ptrT_YoYInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationIndex >(*(ext::shared_ptr< YYZACPIr > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_YoYInflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationTermStructure >(*(ext::shared_ptr< InterpolatedYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseYoYInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_YoYInflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYInflationTermStructure >(*(ext::shared_ptr< PiecewiseYoYInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYOptionletStripperT_Linear_t_tTo_p_ext__shared_ptrT_YoYOptionletStripper_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYOptionletStripper >(*(ext::shared_ptr< InterpolatedYoYOptionletStripper< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_ConstantYoYOptionletVolatility_tTo_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYOptionletVolatilitySurface >(*(ext::shared_ptr< ConstantYoYOptionletVolatility > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedYoYOptionletVolatilityCurveT_Linear_t_tTo_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYOptionletVolatilitySurface >(*(ext::shared_ptr< InterpolatedYoYOptionletVolatilityCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_KInterpolatedYoYOptionletVolatilitySurfaceT_Linear_t_tTo_p_ext__shared_ptrT_YoYOptionletVolatilitySurface_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< YoYOptionletVolatilitySurface >(*(ext::shared_ptr< KInterpolatedYoYOptionletVolatilitySurface< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_AUCPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< AUCPI > *)x);
}
static void *_p_ext__shared_ptrT_EUHICP_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< EUHICP > *)x);
}
static void *_p_ext__shared_ptrT_EUHICPXT_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< EUHICPXT > *)x);
}
static void *_p_ext__shared_ptrT_FRHICP_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< FRHICP > *)x);
}
static void *_p_ext__shared_ptrT_UKHICP_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< UKHICP > *)x);
}
static void *_p_ext__shared_ptrT_UKRPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< UKRPI > *)x);
}
static void *_p_ext__shared_ptrT_USCPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< USCPI > *)x);
}
static void *_p_ext__shared_ptrT_ZACPI_tTo_p_ext__shared_ptrT_ZeroInflationIndex_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationIndex >(*(ext::shared_ptr< ZACPI > *)x);
}
static void *_p_ext__shared_ptrT_InterpolatedZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_ZeroInflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationTermStructure >(*(ext::shared_ptr< InterpolatedZeroInflationCurve< Linear > > *)x);
}
static void *_p_ext__shared_ptrT_PiecewiseZeroInflationCurveT_Linear_t_tTo_p_ext__shared_ptrT_ZeroInflationTermStructure_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new ext::shared_ptr< ZeroInflationTermStructure >(*(ext::shared_ptr< PiecewiseZeroInflationCurve< Linear > > *)x);
}
static swig_type_info _swigt__p_ASX = {"_p_ASX", "ASX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AUCPI = {"_p_AUCPI", "AUCPI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AUDLibor = {"_p_AUDLibor", "AUDLibor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AbcdFunction = {"_p_AbcdFunction", "AbcdFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AbcdMathFunction = {"_p_AbcdMathFunction", "AbcdMathFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AbcdVol = {"_p_AbcdVol", "AbcdVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AdaptiveRungeKuttaT_double_t = {"_p_AdaptiveRungeKuttaT_double_t", "AdaptiveRungeKutta< Real > *|AdaptiveRungeKutta< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AmericanExercise = {"_p_AmericanExercise", "AmericanExercise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AmortizingCmsRateBond = {"_p_AmortizingCmsRateBond", "AmortizingCmsRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AmortizingFixedRateBond = {"_p_AmortizingFixedRateBond", "AmortizingFixedRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AmortizingFloatingRateBond = {"_p_AmortizingFloatingRateBond", "AmortizingFloatingRateBond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AmortizingPayment = {"_p_AmortizingPayment", "AmortizingPayment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticAmericanMargrabeEngine = {"_p_AnalyticAmericanMargrabeEngine", "AnalyticAmericanMargrabeEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticBSMHullWhiteEngine = {"_p_AnalyticBSMHullWhiteEngine", "AnalyticBSMHullWhiteEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticBarrierEngine = {"_p_AnalyticBarrierEngine", "AnalyticBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticBinaryBarrierEngine = {"_p_AnalyticBinaryBarrierEngine", "AnalyticBinaryBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticCEVEngine = {"_p_AnalyticCEVEngine", "AnalyticCEVEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticCapFloorEngine = {"_p_AnalyticCapFloorEngine", "AnalyticCapFloorEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticCliquetEngine = {"_p_AnalyticCliquetEngine", "AnalyticCliquetEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticComplexChooserEngine = {"_p_AnalyticComplexChooserEngine", "AnalyticComplexChooserEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticCompoundOptionEngine = {"_p_AnalyticCompoundOptionEngine", "AnalyticCompoundOptionEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticContinuousFixedLookbackEngine = {"_p_AnalyticContinuousFixedLookbackEngine", "AnalyticContinuousFixedLookbackEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticContinuousFloatingLookbackEngine = {"_p_AnalyticContinuousFloatingLookbackEngine", "AnalyticContinuousFloatingLookbackEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticContinuousGeometricAveragePriceAsianEngine = {"_p_AnalyticContinuousGeometricAveragePriceAsianEngine", "AnalyticContinuousGeometricAveragePriceAsianEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticContinuousGeometricAveragePriceAsianHestonEngine = {"_p_AnalyticContinuousGeometricAveragePriceAsianHestonEngine", "AnalyticContinuousGeometricAveragePriceAsianHestonEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticContinuousPartialFixedLookbackEngine = {"_p_AnalyticContinuousPartialFixedLookbackEngine", "AnalyticContinuousPartialFixedLookbackEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticContinuousPartialFloatingLookbackEngine = {"_p_AnalyticContinuousPartialFloatingLookbackEngine", "AnalyticContinuousPartialFloatingLookbackEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDigitalAmericanEngine = {"_p_AnalyticDigitalAmericanEngine", "AnalyticDigitalAmericanEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDigitalAmericanKOEngine = {"_p_AnalyticDigitalAmericanKOEngine", "AnalyticDigitalAmericanKOEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDiscreteGeometricAveragePriceAsianEngine = {"_p_AnalyticDiscreteGeometricAveragePriceAsianEngine", "AnalyticDiscreteGeometricAveragePriceAsianEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine = {"_p_AnalyticDiscreteGeometricAveragePriceAsianHestonEngine", "AnalyticDiscreteGeometricAveragePriceAsianHestonEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDiscreteGeometricAverageStrikeAsianEngine = {"_p_AnalyticDiscreteGeometricAverageStrikeAsianEngine", "AnalyticDiscreteGeometricAverageStrikeAsianEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDividendEuropeanEngine = {"_p_AnalyticDividendEuropeanEngine", "AnalyticDividendEuropeanEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDoubleBarrierBinaryEngine = {"_p_AnalyticDoubleBarrierBinaryEngine", "AnalyticDoubleBarrierBinaryEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticDoubleBarrierEngine = {"_p_AnalyticDoubleBarrierEngine", "AnalyticDoubleBarrierEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticEuropeanEngine = {"_p_AnalyticEuropeanEngine", "AnalyticEuropeanEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticEuropeanMargrabeEngine = {"_p_AnalyticEuropeanMargrabeEngine", "AnalyticEuropeanMargrabeEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticGJRGARCHEngine = {"_p_AnalyticGJRGARCHEngine", "AnalyticGJRGARCHEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticH1HWEngine = {"_p_AnalyticH1HWEngine", "AnalyticH1HWEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnalyticHaganPricer = {"_p_AnalyticHaganPricer", "AnalyticHaganPricer *", 0, 0, (void*)0, 0};
static